i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

userlandfs: Fix 64 bit debug build.

Browse Source
This commit is contained in:
Michael Lotz
2015-04-18 22:31:11 +02:00
parent 197dbe5313
commit eebdc855b8
7 changed files with 155 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/FileSystem.cpp
+5 -4
View File
@@ -234,7 +234,8 @@ status_t
FileSystem::Init(const char* name, team_id team, Port::Info* infos, int32 count, FileSystem::Init(const char* name, team_id team, Port::Info* infos, int32 count,
const FSCapabilities& capabilities) const FSCapabilities& capabilities)
{ {
PRINT(("FileSystem::Init(\"%s\", %p, %ld)\n", name, infos, count)); PRINT(("FileSystem::Init(\"%s\", %p, %" B_PRId32 ")\n", name, infos,
count));
capabilities.Dump(); capabilities.Dump();
// check parameters // check parameters
@@ -295,13 +296,13 @@ FileSystem::Init(const char* name, team_id team, Port::Info* infos, int32 count,
// print some info about the userland team // print some info about the userland team
D( D(
PRINT((" userland team is: %ld\n", fUserlandServerTeam)); PRINT((" userland team is: %" B_PRId32 "\n", fUserlandServerTeam));
int32 cookie = 0; int32 cookie = 0;
thread_info threadInfo; thread_info threadInfo;
while (get_next_thread_info(fUserlandServerTeam, &cookie, &threadInfo) while (get_next_thread_info(fUserlandServerTeam, &cookie, &threadInfo)
== B_OK) { == B_OK) {
PRINT((" userland thread: %ld: `%s'\n", threadInfo.thread, PRINT((" userland thread: %" B_PRId32 ": `%s'\n",
threadInfo.name)); threadInfo.thread, threadInfo.name));
} }
); );
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/KernelRequestHandler.cpp
+3 -2
View File
@@ -118,8 +118,9 @@ KernelRequestHandler::HandleRequest(Request* request)
case REMOVE_NODE_LISTENER_REQUEST: case REMOVE_NODE_LISTENER_REQUEST:
return _HandleRequest((RemoveNodeListenerRequest*)request); return _HandleRequest((RemoveNodeListenerRequest*)request);
} }
PRINT(("KernelRequestHandler::HandleRequest(): unexpected request: %lu\n",
request->GetType())); PRINT(("KernelRequestHandler::HandleRequest(): unexpected request: %"
B_PRIu32 "\n", request->GetType()));
return B_BAD_DATA; return B_BAD_DATA;
} }
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/Settings.cpp
+3 -2
View File
@@ -248,8 +248,9 @@ Settings::Dump() const
it.HasNext();) { it.HasNext();) {
IOCtlInfoMap::Entry entry = it.Next(); IOCtlInfoMap::Entry entry = it.Next();
IOCtlInfo* info = entry.value; IOCtlInfo* info = entry.value;
PRINT((" ioctl %d: buffer size: %ld, write buffer size: %ld\n", PRINT((" ioctl %d: buffer size: %" B_PRId32
info->command, info->bufferSize, info->writeBufferSize)); ", write buffer size: %" B_PRId32 "\n", info->command,
info->bufferSize, info->writeBufferSize));
} }
} }
) )
src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp
+130 -107
View File
@@ -72,8 +72,9 @@ static status_t
userlandfs_mount(fs_volume* fsVolume, const char* device, uint32 flags, userlandfs_mount(fs_volume* fsVolume, const char* device, uint32 flags,
const char* args, ino_t* rootVnodeID) const char* args, ino_t* rootVnodeID)
{ {
PRINT(("userlandfs_mount(%p (%ld), %s, 0x%lx, %s, %p)\n", fsVolume, PRINT(("userlandfs_mount(%p (%" B_PRId32 "), %s, 0x%" B_PRIx32
fsVolume->id, device, flags, args, rootVnodeID)); ", %s, %p)\n", fsVolume, fsVolume->id, device, flags, args,
rootVnodeID));
status_t error = B_OK; status_t error = B_OK;
@@ -108,8 +109,8 @@ userlandfs_mount(fs_volume* fsVolume, const char* device, uint32 flags,
fsVolume->ops = volume->GetVolumeOps(); fsVolume->ops = volume->GetVolumeOps();
*rootVnodeID = volume->GetRootID(); *rootVnodeID = volume->GetRootID();
PRINT(("userlandfs_mount() done: %p, %lld\n", fsVolume->private_volume, PRINT(("userlandfs_mount() done: %p, %" B_PRIdINO "\n",
*rootVnodeID)); fsVolume->private_volume, *rootVnodeID));
return error; return error;
} }
@@ -128,7 +129,7 @@ userlandfs_unmount(fs_volume* fsVolume)
volume->ReleaseReference(); volume->ReleaseReference();
UserlandFS::GetUserlandFS()->UnregisterFileSystem(fileSystem); UserlandFS::GetUserlandFS()->UnregisterFileSystem(fileSystem);
PRINT(("userlandfs_unmount() done: %lx\n", error)); PRINT(("userlandfs_unmount() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -139,7 +140,7 @@ userlandfs_sync(fs_volume* fsVolume)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_sync(%p)\n", volume)); PRINT(("userlandfs_sync(%p)\n", volume));
status_t error = volume->Sync(); status_t error = volume->Sync();
PRINT(("userlandfs_sync() done: %lx \n", error)); PRINT(("userlandfs_sync() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -150,7 +151,7 @@ userlandfs_read_fs_info(fs_volume* fsVolume, struct fs_info* info)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_fs_info(%p, %p)\n", volume, info)); PRINT(("userlandfs_read_fs_info(%p, %p)\n", volume, info));
status_t error = volume->ReadFSInfo(info); status_t error = volume->ReadFSInfo(info);
PRINT(("userlandfs_read_fs_info() done: %lx \n", error)); PRINT(("userlandfs_read_fs_info() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -160,9 +161,10 @@ userlandfs_write_fs_info(fs_volume* fsVolume, const struct fs_info* info,
uint32 mask) uint32 mask)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_write_fs_info(%p, %p, 0x%lx)\n", volume, info, mask)); PRINT(("userlandfs_write_fs_info(%p, %p, 0x%" B_PRIx32 ")\n", volume, info,
mask));
status_t error = volume->WriteFSInfo(info, mask); status_t error = volume->WriteFSInfo(info, mask);
PRINT(("userlandfs_write_fs_info() done: %lx \n", error)); PRINT(("userlandfs_write_fs_info() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -179,7 +181,8 @@ userlandfs_lookup(fs_volume* fsVolume, fs_vnode* fsDir, const char* entryName,
PRINT(("userlandfs_lookup(%p, %p, `%s', %p)\n", volume, fsDir->private_node, PRINT(("userlandfs_lookup(%p, %p, `%s', %p)\n", volume, fsDir->private_node,
entryName, vnid)); entryName, vnid));
status_t error = volume->Lookup(fsDir->private_node, entryName, vnid); status_t error = volume->Lookup(fsDir->private_node, entryName, vnid);
PRINT(("userlandfs_lookup() done: (%lx, %lld)\n", error, *vnid)); PRINT(("userlandfs_lookup() done: (%" B_PRIx32 ", %" B_PRIdINO ")\n", error,
*vnid));
return error; return error;
} }
@@ -189,12 +192,12 @@ userlandfs_get_vnode_name(fs_volume* fsVolume, fs_vnode* fsNode, char* buffer,
size_t bufferSize) size_t bufferSize)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_get_vnode_name(%p, %p, %p, %lu)\n", volume, PRINT(("userlandfs_get_vnode_name(%p, %p, %p, %" B_PRIuSIZE ")\n", volume,
fsNode->private_node, buffer, bufferSize)); fsNode->private_node, buffer, bufferSize));
status_t error = volume->GetVNodeName(fsNode->private_node, buffer, status_t error = volume->GetVNodeName(fsNode->private_node, buffer,
bufferSize); bufferSize);
PRINT(("userlandfs_get_vnode_name() done: (%lx, \"%.*s\")\n", error, PRINT(("userlandfs_get_vnode_name() done: (%" B_PRIx32 ", \"%.*s\")\n",
(int)bufferSize, (error == B_OK ? buffer : NULL))); error, (int)bufferSize, (error == B_OK ? buffer : NULL)));
return error; return error;
} }
@@ -204,7 +207,7 @@ userlandfs_get_vnode(fs_volume* fsVolume, ino_t vnid, fs_vnode* fsNode,
int* _type, uint32* _flags, bool reenter) int* _type, uint32* _flags, bool reenter)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_get_vnode(%p, %lld, %p, %d)\n", volume, vnid, PRINT(("userlandfs_get_vnode(%p, %" B_PRIdINO ", %p, %d)\n", volume, vnid,
fsNode->private_node, reenter)); fsNode->private_node, reenter));
void* node; void* node;
fs_vnode_ops* ops; fs_vnode_ops* ops;
@@ -215,8 +218,8 @@ userlandfs_get_vnode(fs_volume* fsVolume, ino_t vnid, fs_vnode* fsNode,
fsNode->ops = ops; fsNode->ops = ops;
} }
PRINT(("userlandfs_get_vnode() done: (%lx, %p, %#x, %#lx)\n", error, node, PRINT(("userlandfs_get_vnode() done: (%" B_PRIx32 ", %p, %#x, %#" B_PRIx32
*_type, *_flags)); ")\n", error, node, *_type, *_flags));
return error; return error;
} }
@@ -233,7 +236,7 @@ userlandfs_put_vnode(fs_volume* fsVolume, fs_vnode* fsNode, bool reenter)
// PRINT(("userlandfs_put_vnode(%p, %p, %d)\n", volume, fsNode->private_node, // PRINT(("userlandfs_put_vnode(%p, %p, %d)\n", volume, fsNode->private_node,
// reenter)); // reenter));
status_t error = volume->WriteVNode(fsNode->private_node, reenter); status_t error = volume->WriteVNode(fsNode->private_node, reenter);
// PRINT(("userlandfs_put_vnode() done: %lx\n", error)); // PRINT(("userlandfs_put_vnode() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -246,7 +249,7 @@ userlandfs_remove_vnode(fs_volume* fsVolume, fs_vnode* fsNode, bool reenter)
// PRINT(("userlandfs_remove_vnode(%p, %p, %d)\n", volume, // PRINT(("userlandfs_remove_vnode(%p, %p, %d)\n", volume,
// fsNode->private_node, reenter)); // fsNode->private_node, reenter));
status_t error = volume->RemoveVNode(fsNode->private_node, reenter); status_t error = volume->RemoveVNode(fsNode->private_node, reenter);
// PRINT(("userlandfs_remove_vnode() done: %lx\n", error)); // PRINT(("userlandfs_remove_vnode() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -263,7 +266,7 @@ userlandfs_io(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
PRINT(("userlandfs_io(%p, %p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_io(%p, %p, %p, %p)\n", volume, fsNode->private_node,
cookie, request)); cookie, request));
status_t error = volume->DoIO(fsNode->private_node, cookie, request); status_t error = volume->DoIO(fsNode->private_node, cookie, request);
PRINT(("userlandfs_io() done: (%lx)\n", error)); PRINT(("userlandfs_io() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -277,7 +280,7 @@ userlandfs_cancel_io(fs_volume* fsVolume, fs_vnode* fsNode, void *cookie,
PRINT(("userlandfs_cancel_io(%p, %p, %p, %p)\n", volume, PRINT(("userlandfs_cancel_io(%p, %p, %p, %p)\n", volume,
fsNode->private_node, cookie, request)); fsNode->private_node, cookie, request));
status_t error = volume->CancelIO(fsNode->private_node, cookie, request); status_t error = volume->CancelIO(fsNode->private_node, cookie, request);
PRINT(("userlandfs_cancel_io() done: (%lx)\n", error)); PRINT(("userlandfs_cancel_io() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -291,11 +294,11 @@ userlandfs_ioctl(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, uint32 op,
void* buffer, size_t length) void* buffer, size_t length)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_ioctl(%p, %p, %p, %lu, %p, %lu)\n", volume, PRINT(("userlandfs_ioctl(%p, %p, %p, %" B_PRIu32 ", %p, %" B_PRIuSIZE ")\n",
fsNode->private_node, cookie, op, buffer, length)); volume, fsNode->private_node, cookie, op, buffer, length));
status_t error = volume->IOCtl(fsNode->private_node, cookie, op, buffer, status_t error = volume->IOCtl(fsNode->private_node, cookie, op, buffer,
length); length);
PRINT(("userlandfs_ioctl() done: (%lx)\n", error)); PRINT(("userlandfs_ioctl() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -308,7 +311,7 @@ userlandfs_set_flags(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
PRINT(("userlandfs_set_flags(%p, %p, %p, %d)\n", volume, PRINT(("userlandfs_set_flags(%p, %p, %p, %d)\n", volume,
fsNode->private_node, cookie, flags)); fsNode->private_node, cookie, flags));
status_t error = volume->SetFlags(fsNode->private_node, cookie, flags); status_t error = volume->SetFlags(fsNode->private_node, cookie, flags);
PRINT(("userlandfs_set_flags() done: (%lx)\n", error)); PRINT(("userlandfs_set_flags() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -321,7 +324,7 @@ userlandfs_select(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
PRINT(("userlandfs_select(%p, %p, %p, %hhd, %p)\n", volume, PRINT(("userlandfs_select(%p, %p, %p, %hhd, %p)\n", volume,
fsNode->private_node, cookie, event, sync)); fsNode->private_node, cookie, event, sync));
status_t error = volume->Select(fsNode->private_node, cookie, event, sync); status_t error = volume->Select(fsNode->private_node, cookie, event, sync);
PRINT(("userlandfs_select() done: (%lx)\n", error)); PRINT(("userlandfs_select() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -335,7 +338,7 @@ userlandfs_deselect(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
fsNode->private_node, cookie, event, sync)); fsNode->private_node, cookie, event, sync));
status_t error = volume->Deselect(fsNode->private_node, cookie, event, status_t error = volume->Deselect(fsNode->private_node, cookie, event,
sync); sync);
PRINT(("userlandfs_deselect() done: (%lx)\n", error)); PRINT(("userlandfs_deselect() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -346,7 +349,7 @@ userlandfs_fsync(fs_volume* fsVolume, fs_vnode* fsNode)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_fsync(%p, %p)\n", volume, fsNode->private_node)); PRINT(("userlandfs_fsync(%p, %p)\n", volume, fsNode->private_node));
status_t error = volume->FSync(fsNode->private_node); status_t error = volume->FSync(fsNode->private_node);
PRINT(("userlandfs_fsync() done: %lx\n", error)); PRINT(("userlandfs_fsync() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -356,11 +359,12 @@ userlandfs_read_symlink(fs_volume* fsVolume, fs_vnode* fsLink, char* buffer,
size_t* bufferSize) size_t* bufferSize)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_symlink(%p, %p, %p, %lu)\n", volume, PRINT(("userlandfs_read_symlink(%p, %p, %p, %" B_PRIuSIZE ")\n", volume,
fsLink->private_node, buffer, *bufferSize)); fsLink->private_node, buffer, *bufferSize));
status_t error = volume->ReadSymlink(fsLink->private_node, buffer, status_t error = volume->ReadSymlink(fsLink->private_node, buffer,
*bufferSize, bufferSize); *bufferSize, bufferSize);
PRINT(("userlandfs_read_symlink() done: (%lx, %lu)\n", error, *bufferSize)); PRINT(("userlandfs_read_symlink() done: (%" B_PRIx32 ", %" B_PRIuSIZE ")\n",
error, *bufferSize));
return error; return error;
} }
@@ -374,7 +378,7 @@ userlandfs_create_symlink(fs_volume* fsVolume, fs_vnode* fsDir,
fsDir->private_node, name, path, mode)); fsDir->private_node, name, path, mode));
status_t error = volume->CreateSymlink(fsDir->private_node, name, path, status_t error = volume->CreateSymlink(fsDir->private_node, name, path,
mode); mode);
PRINT(("userlandfs_create_symlink() done: (%lx)\n", error)); PRINT(("userlandfs_create_symlink() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -388,7 +392,7 @@ userlandfs_link(fs_volume* fsVolume, fs_vnode* fsDir, const char* name,
fsDir->private_node, name, fsNode->private_node)); fsDir->private_node, name, fsNode->private_node));
status_t error = volume->Link(fsDir->private_node, name, status_t error = volume->Link(fsDir->private_node, name,
fsNode->private_node); fsNode->private_node);
PRINT(("userlandfs_link() done: (%lx)\n", error)); PRINT(("userlandfs_link() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -400,7 +404,7 @@ userlandfs_unlink(fs_volume* fsVolume, fs_vnode* fsDir, const char* name)
PRINT(("userlandfs_unlink(%p, %p, `%s')\n", volume, fsDir->private_node, PRINT(("userlandfs_unlink(%p, %p, `%s')\n", volume, fsDir->private_node,
name)); name));
status_t error = volume->Unlink(fsDir->private_node, name); status_t error = volume->Unlink(fsDir->private_node, name);
PRINT(("userlandfs_unlink() done: (%lx)\n", error)); PRINT(("userlandfs_unlink() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -414,7 +418,7 @@ userlandfs_rename(fs_volume* fsVolume, fs_vnode* fsFromDir,
fsFromDir->private_node, fromName, fsToDir->private_node, toName)); fsFromDir->private_node, fromName, fsToDir->private_node, toName));
status_t error = volume->Rename(fsFromDir->private_node, fromName, status_t error = volume->Rename(fsFromDir->private_node, fromName,
fsToDir->private_node, toName); fsToDir->private_node, toName);
PRINT(("userlandfs_rename() done: (%lx)\n", error)); PRINT(("userlandfs_rename() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -426,7 +430,7 @@ userlandfs_access(fs_volume* fsVolume, fs_vnode* fsNode, int mode)
PRINT(("userlandfs_access(%p, %p, %d)\n", volume, fsNode->private_node, PRINT(("userlandfs_access(%p, %p, %d)\n", volume, fsNode->private_node,
mode)); mode));
status_t error = volume->Access(fsNode->private_node, mode); status_t error = volume->Access(fsNode->private_node, mode);
PRINT(("userlandfs_access() done: %lx\n", error)); PRINT(("userlandfs_access() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -438,7 +442,7 @@ userlandfs_read_stat(fs_volume* fsVolume, fs_vnode* fsNode, struct stat* st)
PRINT(("userlandfs_read_stat(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_read_stat(%p, %p, %p)\n", volume, fsNode->private_node,
st)); st));
status_t error = volume->ReadStat(fsNode->private_node, st); status_t error = volume->ReadStat(fsNode->private_node, st);
PRINT(("userlandfs_read_stat() done: %lx\n", error)); PRINT(("userlandfs_read_stat() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -448,10 +452,10 @@ userlandfs_write_stat(fs_volume* fsVolume, fs_vnode* fsNode,
const struct stat* st, uint32 mask) const struct stat* st, uint32 mask)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_write_stat(%p, %p, %p, %ld)\n", volume, PRINT(("userlandfs_write_stat(%p, %p, %p, %" B_PRIu32 ")\n", volume,
fsNode->private_node, st, mask)); fsNode->private_node, st, mask));
status_t error = volume->WriteStat(fsNode->private_node, st, mask); status_t error = volume->WriteStat(fsNode->private_node, st, mask);
PRINT(("userlandfs_write_stat() done: %lx\n", error)); PRINT(("userlandfs_write_stat() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -469,8 +473,8 @@ userlandfs_create(fs_volume* fsVolume, fs_vnode* fsDir, const char* name,
fsDir->private_node, name, openMode, perms, cookie, vnid)); fsDir->private_node, name, openMode, perms, cookie, vnid));
status_t error = volume->Create(fsDir->private_node, name, openMode, perms, status_t error = volume->Create(fsDir->private_node, name, openMode, perms,
cookie, vnid); cookie, vnid);
PRINT(("userlandfs_create() done: (%lx, %lld, %p)\n", error, *vnid, PRINT(("userlandfs_create() done: (%" B_PRIx32 ", %" B_PRIdINO ", %p)\n",
*cookie)); error, *vnid, *cookie));
return error; return error;
} }
@@ -483,7 +487,7 @@ userlandfs_open(fs_volume* fsVolume, fs_vnode* fsNode, int openMode,
PRINT(("userlandfs_open(%p, %p, %d)\n", volume, fsNode->private_node, PRINT(("userlandfs_open(%p, %p, %d)\n", volume, fsNode->private_node,
openMode)); openMode));
status_t error = volume->Open(fsNode->private_node, openMode, cookie); status_t error = volume->Open(fsNode->private_node, openMode, cookie);
PRINT(("userlandfs_open() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open() done: (%" B_PRIx32 ", %p)\n", error, *cookie));
return error; return error;
} }
@@ -495,7 +499,7 @@ userlandfs_close(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_close(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_close(%p, %p, %p)\n", volume, fsNode->private_node,
cookie)); cookie));
status_t error = volume->Close(fsNode->private_node, cookie); status_t error = volume->Close(fsNode->private_node, cookie);
PRINT(("userlandfs_close() done: %lx\n", error)); PRINT(("userlandfs_close() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -507,7 +511,7 @@ userlandfs_free_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_free_cookie(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_free_cookie(%p, %p, %p)\n", volume, fsNode->private_node,
cookie)); cookie));
status_t error = volume->FreeCookie(fsNode->private_node, cookie); status_t error = volume->FreeCookie(fsNode->private_node, cookie);
PRINT(("userlandfs_free_cookie() done: %lx\n", error)); PRINT(("userlandfs_free_cookie() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -517,11 +521,12 @@ userlandfs_read(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, off_t pos,
void* buffer, size_t* length) void* buffer, size_t* length)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read(%p, %p, %p, %Ld, %p, %lu)\n", volume, PRINT(("userlandfs_read(%p, %p, %p, %" B_PRIdOFF ", %p, %" B_PRIuSIZE ")\n",
fsNode->private_node, cookie, pos, buffer, *length)); volume, fsNode->private_node, cookie, pos, buffer, *length));
status_t error = volume->Read(fsNode->private_node, cookie, pos, buffer, status_t error = volume->Read(fsNode->private_node, cookie, pos, buffer,
*length, length); *length, length);
PRINT(("userlandfs_read() done: (%lx, %lu)\n", error, *length)); PRINT(("userlandfs_read() done: (%" B_PRIx32 ", %" B_PRIuSIZE ")\n", error,
*length));
return error; return error;
} }
@@ -531,11 +536,12 @@ userlandfs_write(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie, off_t pos,
const void* buffer, size_t* length) const void* buffer, size_t* length)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_write(%p, %p, %p, %Ld, %p, %lu)\n", volume, PRINT(("userlandfs_write(%p, %p, %p, %" B_PRIdOFF ", %p, %" B_PRIuSIZE
fsNode->private_node, cookie, pos, buffer, *length)); ")\n", volume, fsNode->private_node, cookie, pos, buffer, *length));
status_t error = volume->Write(fsNode->private_node, cookie, pos, buffer, status_t error = volume->Write(fsNode->private_node, cookie, pos, buffer,
*length, length); *length, length);
PRINT(("userlandfs_write() done: (%lx, %lu)\n", error, *length)); PRINT(("userlandfs_write() done: (%" B_PRIx32 ", %" B_PRIuSIZE ")\n", error,
*length));
return error; return error;
} }
@@ -552,7 +558,7 @@ userlandfs_create_dir(fs_volume* fsVolume, fs_vnode* fsParent, const char* name,
PRINT(("userlandfs_create_dir(%p, %p, `%s', %#x)\n", volume, PRINT(("userlandfs_create_dir(%p, %p, `%s', %#x)\n", volume,
fsParent->private_node, name, perms)); fsParent->private_node, name, perms));
status_t error = volume->CreateDir(fsParent->private_node, name, perms); status_t error = volume->CreateDir(fsParent->private_node, name, perms);
PRINT(("userlandfs_create_dir() done: (%lx)\n", error)); PRINT(("userlandfs_create_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -564,7 +570,7 @@ userlandfs_remove_dir(fs_volume* fsVolume, fs_vnode* fsParent, const char* name)
PRINT(("userlandfs_remove_dir(%p, %p, `%s')\n", volume, PRINT(("userlandfs_remove_dir(%p, %p, `%s')\n", volume,
fsParent->private_node, name)); fsParent->private_node, name));
status_t error = volume->RemoveDir(fsParent->private_node, name); status_t error = volume->RemoveDir(fsParent->private_node, name);
PRINT(("userlandfs_remove_dir() done: (%lx)\n", error)); PRINT(("userlandfs_remove_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -575,7 +581,8 @@ userlandfs_open_dir(fs_volume* fsVolume, fs_vnode* fsNode, void** cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_open_dir(%p, %p)\n", volume, fsNode->private_node)); PRINT(("userlandfs_open_dir(%p, %p)\n", volume, fsNode->private_node));
status_t error = volume->OpenDir(fsNode->private_node, cookie); status_t error = volume->OpenDir(fsNode->private_node, cookie);
PRINT(("userlandfs_open_dir() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open_dir() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -587,7 +594,7 @@ userlandfs_close_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_close_dir(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_close_dir(%p, %p, %p)\n", volume, fsNode->private_node,
cookie)); cookie));
status_t error = volume->CloseDir(fsNode->private_node, cookie); status_t error = volume->CloseDir(fsNode->private_node, cookie);
PRINT(("userlandfs_close_dir() done: %lx\n", error)); PRINT(("userlandfs_close_dir() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -599,7 +606,7 @@ userlandfs_free_dir_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_free_dir_cookie(%p, %p, %p)\n", volume, PRINT(("userlandfs_free_dir_cookie(%p, %p, %p)\n", volume,
fsNode->private_node, cookie)); fsNode->private_node, cookie));
status_t error = volume->FreeDirCookie(fsNode->private_node, cookie); status_t error = volume->FreeDirCookie(fsNode->private_node, cookie);
PRINT(("userlandfs_free_dir_cookie() done: %lx \n", error)); PRINT(("userlandfs_free_dir_cookie() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -609,11 +616,13 @@ userlandfs_read_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
struct dirent* buffer, size_t bufferSize, uint32* count) struct dirent* buffer, size_t bufferSize, uint32* count)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_dir(%p, %p, %p, %p, %lu, %lu)\n", volume, PRINT(("userlandfs_read_dir(%p, %p, %p, %p, %" B_PRIuSIZE ", %" B_PRIu32
fsNode->private_node, cookie, buffer, bufferSize, *count)); ")\n", volume, fsNode->private_node, cookie, buffer, bufferSize,
*count));
status_t error = volume->ReadDir(fsNode->private_node, cookie, buffer, status_t error = volume->ReadDir(fsNode->private_node, cookie, buffer,
bufferSize, *count, count); bufferSize, *count, count);
PRINT(("userlandfs_read_dir() done: (%lx, %lu)\n", error, *count)); PRINT(("userlandfs_read_dir() done: (%" B_PRIx32 ", %" B_PRIu32 ")\n",
error, *count));
#if DEBUG #if DEBUG
dirent* entry = buffer; dirent* entry = buffer;
for (uint32 i = 0; error == B_OK && i < *count; i++) { for (uint32 i = 0; error == B_OK && i < *count; i++) {
@@ -623,8 +632,9 @@ userlandfs_read_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
int nameLen = strnlen(entry->d_name, B_FILE_NAME_LENGTH - 1); int nameLen = strnlen(entry->d_name, B_FILE_NAME_LENGTH - 1);
strncpy(name, entry->d_name, nameLen); strncpy(name, entry->d_name, nameLen);
name[nameLen] = '\0'; name[nameLen] = '\0';
PRINT((" entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld, d_pino: %Ld, " PRINT((" entry: d_dev: %" B_PRIdDEV ", d_pdev: %" B_PRIdDEV
"d_reclen: %hu, d_name: `%s'\n", ", d_ino: %" B_PRIdINO ", d_pino: %" B_PRIdINO ", "
"d_reclen: %" B_PRIu16 ", d_name: `%s'\n",
entry->d_dev, entry->d_pdev, entry->d_ino, entry->d_pino, entry->d_dev, entry->d_pdev, entry->d_ino, entry->d_pino,
entry->d_reclen, name)); entry->d_reclen, name));
entry = (dirent*)((char*)entry + entry->d_reclen); entry = (dirent*)((char*)entry + entry->d_reclen);
@@ -641,7 +651,7 @@ userlandfs_rewind_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_rewind_dir(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_rewind_dir(%p, %p, %p)\n", volume, fsNode->private_node,
cookie)); cookie));
status_t error = volume->RewindDir(fsNode->private_node, cookie); status_t error = volume->RewindDir(fsNode->private_node, cookie);
PRINT(("userlandfs_rewind_dir() done: %lx\n", error)); PRINT(("userlandfs_rewind_dir() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -656,7 +666,8 @@ userlandfs_open_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void** cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_open_attr_dir(%p, %p)\n", volume, fsNode->private_node)); PRINT(("userlandfs_open_attr_dir(%p, %p)\n", volume, fsNode->private_node));
status_t error = volume->OpenAttrDir(fsNode->private_node, cookie); status_t error = volume->OpenAttrDir(fsNode->private_node, cookie);
PRINT(("userlandfs_open_attr_dir() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open_attr_dir() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -668,7 +679,7 @@ userlandfs_close_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_close_attr_dir(%p, %p, %p)\n", volume, PRINT(("userlandfs_close_attr_dir(%p, %p, %p)\n", volume,
fsNode->private_node, cookie)); fsNode->private_node, cookie));
status_t error = volume->CloseAttrDir(fsNode->private_node, cookie); status_t error = volume->CloseAttrDir(fsNode->private_node, cookie);
PRINT(("userlandfs_close_attr_dir() done: (%lx)\n", error)); PRINT(("userlandfs_close_attr_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -681,7 +692,7 @@ userlandfs_free_attr_dir_cookie(fs_volume* fsVolume, fs_vnode* fsNode,
PRINT(("userlandfs_free_attr_dir_cookie(%p, %p, %p)\n", volume, PRINT(("userlandfs_free_attr_dir_cookie(%p, %p, %p)\n", volume,
fsNode->private_node, cookie)); fsNode->private_node, cookie));
status_t error = volume->FreeAttrDirCookie(fsNode->private_node, cookie); status_t error = volume->FreeAttrDirCookie(fsNode->private_node, cookie);
PRINT(("userlandfs_free_attr_dir_cookie() done: (%lx)\n", error)); PRINT(("userlandfs_free_attr_dir_cookie() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -691,11 +702,13 @@ userlandfs_read_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
struct dirent* buffer, size_t bufferSize, uint32* count) struct dirent* buffer, size_t bufferSize, uint32* count)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_attr_dir(%p, %p, %p, %p, %lu, %lu)\n", volume, PRINT(("userlandfs_read_attr_dir(%p, %p, %p, %p, %" B_PRIuSIZE ", %"
fsNode->private_node, cookie, buffer, bufferSize, *count)); B_PRIu32 ")\n", volume, fsNode->private_node, cookie, buffer,
bufferSize, *count));
status_t error = volume->ReadAttrDir(fsNode->private_node, cookie, buffer, status_t error = volume->ReadAttrDir(fsNode->private_node, cookie, buffer,
bufferSize, *count, count); bufferSize, *count, count);
PRINT(("userlandfs_read_attr_dir() done: (%lx, %lu)\n", error, *count)); PRINT(("userlandfs_read_attr_dir() done: (%" B_PRIx32 ", %" B_PRIu32 ")\n",
error, *count));
return error; return error;
} }
@@ -707,7 +720,7 @@ userlandfs_rewind_attr_dir(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_rewind_attr_dir(%p, %p, %p)\n", volume, PRINT(("userlandfs_rewind_attr_dir(%p, %p, %p)\n", volume,
fsNode->private_node, cookie)); fsNode->private_node, cookie));
status_t error = volume->RewindAttrDir(fsNode->private_node, cookie); status_t error = volume->RewindAttrDir(fsNode->private_node, cookie);
PRINT(("userlandfs_rewind_attr_dir() done: (%lx)\n", error)); PRINT(("userlandfs_rewind_attr_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -721,11 +734,12 @@ userlandfs_create_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name,
uint32 type, int openMode, void** cookie) uint32 type, int openMode, void** cookie)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_create_attr(%p, %p, \"%s\", 0x%lx, %d, %p)\n", volume, PRINT(("userlandfs_create_attr(%p, %p, \"%s\", 0x%" B_PRIx32 ", %d, %p)\n",
fsNode->private_node, name, type, openMode, cookie)); volume, fsNode->private_node, name, type, openMode, cookie));
status_t error = volume->CreateAttr(fsNode->private_node, name, type, status_t error = volume->CreateAttr(fsNode->private_node, name, type,
openMode, cookie); openMode, cookie);
PRINT(("userlandfs_create_attr() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_create_attr() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -739,7 +753,8 @@ userlandfs_open_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name,
fsNode->private_node, name, openMode, cookie)); fsNode->private_node, name, openMode, cookie));
status_t error = volume->OpenAttr(fsNode->private_node, name, openMode, status_t error = volume->OpenAttr(fsNode->private_node, name, openMode,
cookie); cookie);
PRINT(("userlandfs_open_attr() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open_attr() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -751,7 +766,7 @@ userlandfs_close_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_close_attr(%p, %p, %p)\n", volume, fsNode->private_node, PRINT(("userlandfs_close_attr(%p, %p, %p)\n", volume, fsNode->private_node,
cookie)); cookie));
status_t error = volume->CloseAttr(fsNode->private_node, cookie); status_t error = volume->CloseAttr(fsNode->private_node, cookie);
PRINT(("userlandfs_close_attr() done: %lx\n", error)); PRINT(("userlandfs_close_attr() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -763,7 +778,7 @@ userlandfs_free_attr_cookie(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie)
PRINT(("userlandfs_free_attr_cookie(%p, %p, %p)\n", volume, PRINT(("userlandfs_free_attr_cookie(%p, %p, %p)\n", volume,
fsNode->private_node, cookie)); fsNode->private_node, cookie));
status_t error = volume->FreeAttrCookie(fsNode->private_node, cookie); status_t error = volume->FreeAttrCookie(fsNode->private_node, cookie);
PRINT(("userlandfs_free_attr_cookie() done: %lx\n", error)); PRINT(("userlandfs_free_attr_cookie() done: %" B_PRIx32 "\n", error));
return error; return error;
} }
@@ -773,11 +788,13 @@ userlandfs_read_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
off_t pos, void* buffer, size_t* length) off_t pos, void* buffer, size_t* length)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_attr(%p, %p, %p, %lld, %p, %lu)\n", volume, PRINT(("userlandfs_read_attr(%p, %p, %p, %" B_PRIdOFF ", %p, %"
fsNode->private_node, cookie, pos, buffer, *length)); B_PRIuSIZE ")\n", volume, fsNode->private_node, cookie, pos, buffer,
*length));
status_t error = volume->ReadAttr(fsNode->private_node, cookie, pos, buffer, status_t error = volume->ReadAttr(fsNode->private_node, cookie, pos, buffer,
*length, length); *length, length);
PRINT(("userlandfs_read_attr() done: (%lx, %lu)\n", error, *length)); PRINT(("userlandfs_read_attr() done: (%" B_PRIx32 ", %" B_PRIuSIZE ")\n",
error, *length));
return error; return error;
} }
@@ -787,11 +804,12 @@ userlandfs_write_attr(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
off_t pos, const void* buffer, size_t* length) off_t pos, const void* buffer, size_t* length)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_write_attr(%p, %p, %p, %lld, %p, %lu)\n", volume, PRINT(("userlandfs_write_attr(%p, %p, %p, %" B_PRIdOFF ", %p, %" B_PRIuSIZE
fsNode->private_node, cookie, pos, buffer, *length)); ")\n", volume, fsNode->private_node, cookie, pos, buffer, *length));
status_t error = volume->WriteAttr(fsNode->private_node, cookie, pos, status_t error = volume->WriteAttr(fsNode->private_node, cookie, pos,
buffer, *length, length); buffer, *length, length);
PRINT(("userlandfs_write_attr() done: (%lx, %lu)\n", error, *length)); PRINT(("userlandfs_write_attr() done: (%" B_PRIx32 ", %" B_PRIuSIZE ")\n",
error, *length));
return error; return error;
} }
@@ -804,7 +822,7 @@ userlandfs_read_attr_stat(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
PRINT(("userlandfs_read_attr_stat(%p, %p, %p, %p)\n", volume, PRINT(("userlandfs_read_attr_stat(%p, %p, %p, %p)\n", volume,
fsNode->private_node, cookie, st)); fsNode->private_node, cookie, st));
status_t error = volume->ReadAttrStat(fsNode->private_node, cookie, st); status_t error = volume->ReadAttrStat(fsNode->private_node, cookie, st);
PRINT(("userlandfs_read_attr_stat() done: (%lx)\n", error)); PRINT(("userlandfs_read_attr_stat() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -818,7 +836,7 @@ userlandfs_write_attr_stat(fs_volume* fsVolume, fs_vnode* fsNode, void* cookie,
fsNode->private_node, cookie, st, statMask)); fsNode->private_node, cookie, st, statMask));
status_t error = volume->WriteAttrStat(fsNode->private_node, cookie, st, status_t error = volume->WriteAttrStat(fsNode->private_node, cookie, st,
statMask); statMask);
PRINT(("userlandfs_write_attr_stat() done: (%lx)\n", error)); PRINT(("userlandfs_write_attr_stat() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -832,7 +850,7 @@ userlandfs_rename_attr(fs_volume* fsVolume, fs_vnode* fsFromNode,
fsFromNode->private_node, fromName, fsToNode->private_node, toName)); fsFromNode->private_node, fromName, fsToNode->private_node, toName));
status_t error = volume->RenameAttr(fsFromNode->private_node, fromName, status_t error = volume->RenameAttr(fsFromNode->private_node, fromName,
fsToNode->private_node, toName); fsToNode->private_node, toName);
PRINT(("userlandfs_rename_attr() done: (%lx)\n", error)); PRINT(("userlandfs_rename_attr() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -844,7 +862,7 @@ userlandfs_remove_attr(fs_volume* fsVolume, fs_vnode* fsNode, const char* name)
PRINT(("userlandfs_remove_attr(%p, %p, `%s')\n", volume, PRINT(("userlandfs_remove_attr(%p, %p, `%s')\n", volume,
fsNode->private_node, name)); fsNode->private_node, name));
status_t error = volume->RemoveAttr(fsNode->private_node, name); status_t error = volume->RemoveAttr(fsNode->private_node, name);
PRINT(("userlandfs_remove_attr() done: (%lx)\n", error)); PRINT(("userlandfs_remove_attr() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -859,7 +877,8 @@ userlandfs_open_index_dir(fs_volume* fsVolume, void** cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_open_index_dir(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_open_index_dir(%p, %p)\n", volume, cookie));
status_t error = volume->OpenIndexDir(cookie); status_t error = volume->OpenIndexDir(cookie);
PRINT(("userlandfs_open_index_dir() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open_index_dir() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -870,7 +889,7 @@ userlandfs_close_index_dir(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_close_index_dir(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_close_index_dir(%p, %p)\n", volume, cookie));
status_t error = volume->CloseIndexDir(cookie); status_t error = volume->CloseIndexDir(cookie);
PRINT(("userlandfs_close_index_dir() done: (%lx)\n", error)); PRINT(("userlandfs_close_index_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -881,7 +900,8 @@ userlandfs_free_index_dir_cookie(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_free_index_dir_cookie(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_free_index_dir_cookie(%p, %p)\n", volume, cookie));
status_t error = volume->FreeIndexDirCookie(cookie); status_t error = volume->FreeIndexDirCookie(cookie);
PRINT(("userlandfs_free_index_dir_cookie() done: (%lx)\n", error)); PRINT(("userlandfs_free_index_dir_cookie() done: (%" B_PRIx32 ")\n",
error));
return error; return error;
} }
@@ -891,11 +911,12 @@ userlandfs_read_index_dir(fs_volume* fsVolume, void* cookie,
struct dirent* buffer, size_t bufferSize, uint32* count) struct dirent* buffer, size_t bufferSize, uint32* count)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_index_dir(%p, %p, %p, %lu, %lu)\n", volume, cookie, PRINT(("userlandfs_read_index_dir(%p, %p, %p, %" B_PRIuSIZE ", %" B_PRIu32
buffer, bufferSize, *count)); ")\n", volume, cookie, buffer, bufferSize, *count));
status_t error = volume->ReadIndexDir(cookie, buffer, bufferSize, status_t error = volume->ReadIndexDir(cookie, buffer, bufferSize,
*count, count); *count, count);
PRINT(("userlandfs_read_index_dir() done: (%lx, %lu)\n", error, *count)); PRINT(("userlandfs_read_index_dir() done: (%" B_PRIx32 ", %" B_PRIu32 ")\n",
error, *count));
return error; return error;
} }
@@ -906,7 +927,7 @@ userlandfs_rewind_index_dir(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_rewind_index_dir(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_rewind_index_dir(%p, %p)\n", volume, cookie));
status_t error = volume->RewindIndexDir(cookie); status_t error = volume->RewindIndexDir(cookie);
PRINT(("userlandfs_rewind_index_dir() done: (%lx)\n", error)); PRINT(("userlandfs_rewind_index_dir() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -916,10 +937,10 @@ userlandfs_create_index(fs_volume* fsVolume, const char* name, uint32 type,
uint32 flags) uint32 flags)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_create_index(%p, `%s', 0x%lx, 0x%lx)\n", volume, name, PRINT(("userlandfs_create_index(%p, `%s', 0x%" B_PRIx32 ", 0x%" B_PRIx32
type, flags)); ")\n", volume, name, type, flags));
status_t error = volume->CreateIndex(name, type, flags); status_t error = volume->CreateIndex(name, type, flags);
PRINT(("userlandfs_create_index() done: (%lx)\n", error)); PRINT(("userlandfs_create_index() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -930,7 +951,7 @@ userlandfs_remove_index(fs_volume* fsVolume, const char* name)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_remove_index(%p, `%s')\n", volume, name)); PRINT(("userlandfs_remove_index(%p, `%s')\n", volume, name));
status_t error = volume->RemoveIndex(name); status_t error = volume->RemoveIndex(name);
PRINT(("userlandfs_remove_index() done: (%lx)\n", error)); PRINT(("userlandfs_remove_index() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -942,7 +963,7 @@ userlandfs_read_index_stat(fs_volume* fsVolume, const char* name,
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_index_stat(%p, `%s', %p)\n", volume, name, st)); PRINT(("userlandfs_read_index_stat(%p, `%s', %p)\n", volume, name, st));
status_t error = volume->ReadIndexStat(name, st); status_t error = volume->ReadIndexStat(name, st);
PRINT(("userlandfs_read_index_stat() done: (%lx)\n", error)); PRINT(("userlandfs_read_index_stat() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -956,10 +977,11 @@ userlandfs_open_query(fs_volume* fsVolume, const char *queryString,
uint32 flags, port_id port, uint32 token, void** cookie) uint32 flags, port_id port, uint32 token, void** cookie)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_open_query(%p, `%s', %lu, %ld, %lu, %p)\n", volume, PRINT(("userlandfs_open_query(%p, `%s', %" B_PRIu32 ", %" B_PRId32 ", %"
queryString, flags, port, token, cookie)); B_PRIu32 ", %p)\n", volume, queryString, flags, port, token, cookie));
status_t error = volume->OpenQuery(queryString, flags, port, token, cookie); status_t error = volume->OpenQuery(queryString, flags, port, token, cookie);
PRINT(("userlandfs_open_query() done: (%lx, %p)\n", error, *cookie)); PRINT(("userlandfs_open_query() done: (%" B_PRIx32 ", %p)\n", error,
*cookie));
return error; return error;
} }
@@ -970,7 +992,7 @@ userlandfs_close_query(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_close_query(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_close_query(%p, %p)\n", volume, cookie));
status_t error = volume->CloseQuery(cookie); status_t error = volume->CloseQuery(cookie);
PRINT(("userlandfs_close_query() done: (%lx)\n", error)); PRINT(("userlandfs_close_query() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -981,7 +1003,7 @@ userlandfs_free_query_cookie(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_free_query_cookie(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_free_query_cookie(%p, %p)\n", volume, cookie));
status_t error = volume->FreeQueryCookie(cookie); status_t error = volume->FreeQueryCookie(cookie);
PRINT(("userlandfs_free_query_cookie() done: (%lx)\n", error)); PRINT(("userlandfs_free_query_cookie() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
@@ -991,11 +1013,12 @@ userlandfs_read_query(fs_volume* fsVolume, void* cookie,
struct dirent* buffer, size_t bufferSize, uint32* count) struct dirent* buffer, size_t bufferSize, uint32* count)
{ {
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_read_query(%p, %p, %p, %lu, %lu)\n", volume, cookie, PRINT(("userlandfs_read_query(%p, %p, %p, %" B_PRIuSIZE ", %" B_PRIu32
buffer, bufferSize, *count)); ")\n", volume, cookie, buffer, bufferSize, *count));
status_t error = volume->ReadQuery(cookie, buffer, bufferSize, *count, status_t error = volume->ReadQuery(cookie, buffer, bufferSize, *count,
count); count);
PRINT(("userlandfs_read_query() done: (%lx, %ld)\n", error, *count)); PRINT(("userlandfs_read_query() done: (%" B_PRIx32 ", %" B_PRIu32 ")\n",
error, *count));
#if DEBUG #if DEBUG
if (error == B_OK && *count > 0) { if (error == B_OK && *count > 0) {
// R5's kernel vsprintf() doesn't seem to know `%.<number>s', so // R5's kernel vsprintf() doesn't seem to know `%.<number>s', so
@@ -1004,10 +1027,10 @@ userlandfs_read_query(fs_volume* fsVolume, void* cookie,
int nameLen = strnlen(buffer->d_name, B_FILE_NAME_LENGTH - 1); int nameLen = strnlen(buffer->d_name, B_FILE_NAME_LENGTH - 1);
strncpy(name, buffer->d_name, nameLen); strncpy(name, buffer->d_name, nameLen);
name[nameLen] = '\0'; name[nameLen] = '\0';
PRINT((" entry: d_dev: %ld, d_pdev: %ld, d_ino: %Ld, d_pino: %Ld, " PRINT((" entry: d_dev: %" B_PRIdDEV ", d_pdev: %" B_PRIdDEV
"d_reclen: %hu, d_name: `%s'\n", ", d_ino: %" B_PRIdINO ", d_pino: %" B_PRIdINO ", d_reclen: %"
buffer->d_dev, buffer->d_pdev, buffer->d_ino, buffer->d_pino, B_PRIu16 ", d_name: `%s'\n", buffer->d_dev, buffer->d_pdev,
buffer->d_reclen, name)); buffer->d_ino, buffer->d_pino, buffer->d_reclen, name));
} }
#endif #endif
return error; return error;
@@ -1020,7 +1043,7 @@ userlandfs_rewind_query(fs_volume* fsVolume, void* cookie)
Volume* volume = (Volume*)fsVolume->private_volume; Volume* volume = (Volume*)fsVolume->private_volume;
PRINT(("userlandfs_rewind_query(%p, %p)\n", volume, cookie)); PRINT(("userlandfs_rewind_query(%p, %p)\n", volume, cookie));
status_t error = volume->RewindQuery(cookie); status_t error = volume->RewindQuery(cookie);
PRINT(("userlandfs_rewind_query() done: (%lx)\n", error)); PRINT(("userlandfs_rewind_query() done: (%" B_PRIx32 ")\n", error));
return error; return error;
} }
src/add-ons/kernel/file_systems/userlandfs/private/RequestAllocator.cpp
+6 -4
View File
@@ -92,8 +92,9 @@ RequestAllocator::FinishDeferredInit()
memcpy((uint8*)fRequest + info.offset, info.data, info.size); memcpy((uint8*)fRequest + info.offset, info.data, info.size);
free(info.data); free(info.data);
} }
PRINT(("RequestAllocator::FinishDeferredInit(): area: %ld, " PRINT(("RequestAllocator::FinishDeferredInit(): area: %" B_PRId32 ", "
"offset: %ld, size: %ld\n", info.area, info.offset, info.size)); "offset: %" B_PRId32 ", size: %" B_PRId32 "\n", info.area,
info.offset, info.size));
info.target->SetTo(info.area, info.offset, info.size); info.target->SetTo(info.area, info.offset, info.size);
} }
fDeferredInitInfoCount = 0; fDeferredInitInfoCount = 0;
@@ -251,8 +252,9 @@ RequestAllocator::AllocateAddress(Address& address, int32 size, int32 align,
info.inPortBuffer = false; info.inPortBuffer = false;
info.target = &address; info.target = &address;
fDeferredInitInfoCount++; fDeferredInitInfoCount++;
PRINT((" RequestAllocator::AllocateAddress(): deferred allocated area: " PRINT((" RequestAllocator::AllocateAddress(): deferred allocated "
"%ld, size: %ld (%ld), data: %p\n", area, size, areaSize, *data)); "area: %" B_PRId32 ", size: %" B_PRId32 " (%" B_PRId32
"), data: %p\n", area, size, areaSize, *data));
} else } else
address.SetTo(area, 0, size); address.SetTo(area, 0, size);
} }
src/add-ons/kernel/file_systems/userlandfs/private/SingleReplyRequestHandler.cpp
+5 -3
View File
@@ -27,10 +27,12 @@ status_t
SingleReplyRequestHandler::HandleRequest(Request* request) SingleReplyRequestHandler::HandleRequest(Request* request)
{ {
if (!fAcceptAnyRequest && request->GetType() != fExpectedReply) { if (!fAcceptAnyRequest && request->GetType() != fExpectedReply) {
PRINT(("SingleReplyRequestHandler::HandleRequest(): unexpected request: %lu " PRINT(("SingleReplyRequestHandler::HandleRequest(): unexpected "
"expected was: %lu\n", request->GetType(), fExpectedReply)); "request: %" B_PRIu32 " expected was: %" B_PRIu32 "\n",
request->GetType(), fExpectedReply));
#if USER #if USER
debugger("SingleReplyRequestHandler::HandleRequest(): unexpected request!"); debugger("SingleReplyRequestHandler::HandleRequest(): unexpected "
"request!");
#endif #endif
return B_BAD_DATA; return B_BAD_DATA;
} }
src/add-ons/kernel/file_systems/userlandfs/server/fuse/FUSEVolume.cpp
+3 -3
View File
@@ -1263,8 +1263,8 @@ status_t
FUSEVolume::WriteStat(void* _node, const struct stat* st, uint32 mask) FUSEVolume::WriteStat(void* _node, const struct stat* st, uint32 mask)
{ {
FUSENode* node = (FUSENode*)_node; FUSENode* node = (FUSENode*)_node;
PRINT(("FUSEVolume::WriteStat(%p (%" B_PRId64 "), %p, %#lx)\n", node, PRINT(("FUSEVolume::WriteStat(%p (%" B_PRId64 "), %p, %#" B_PRIx32 ")\n",
node->id, st, mask)); node, node->id, st, mask));
// lock the directory // lock the directory
NodeReadLocker nodeLocker(this, node, true); NodeReadLocker nodeLocker(this, node, true);
@@ -1827,7 +1827,7 @@ status_t
FUSEVolume::ReadDir(void* _node, void* _cookie, void* buffer, size_t bufferSize, FUSEVolume::ReadDir(void* _node, void* _cookie, void* buffer, size_t bufferSize,
uint32 count, uint32* _countRead) uint32 count, uint32* _countRead)
{ {
PRINT(("FUSEVolume::ReadDir(%p, %p, %p, %" B_PRIu32 ", %" B_PRId32 ")\n", PRINT(("FUSEVolume::ReadDir(%p, %p, %p, %" B_PRIuSIZE ", %" B_PRId32 ")\n",
_node, _cookie, buffer, bufferSize, count)); _node, _cookie, buffer, bufferSize, count));
*_countRead = 0; *_countRead = 0;