[haiku-commits] haiku: hrev49370 - src/add-ons/kernel/file_systems/layers/log_overlay

  • From: mmlr@xxxxxxxx
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Sun, 5 Jul 2015 11:38:03 +0200 (CEST)

hrev49370 adds 1 changeset to branch 'master'
old head: 1a776b25ce1d2d6c8f33daa7f35648dd1b3233cc
new head: 29e8040d58b31033af8c095e3b2f5421197638d2
overview:
http://cgit.haiku-os.org/haiku/log/?qt=range&q=29e8040d58b3+%5E1a776b25ce1d

----------------------------------------------------------------------------

29e8040d58b3: log_overlay: Fix 64 bit build and add to image.

[ Michael Lotz <mmlr@xxxxxxxx> ]

----------------------------------------------------------------------------

Revision: hrev49370
Commit: 29e8040d58b31033af8c095e3b2f5421197638d2
URL: http://cgit.haiku-os.org/haiku/commit/?id=29e8040d58b3
Author: Michael Lotz <mmlr@xxxxxxxx>
Date: Sun Jul 5 08:31:59 2015 UTC

----------------------------------------------------------------------------

2 files changed, 175 insertions(+), 150 deletions(-)
build/jam/images/definitions/minimum | 1 +
.../layers/log_overlay/log_overlay.cpp | 324 ++++++++++---------

----------------------------------------------------------------------------

diff --git a/build/jam/images/definitions/minimum
b/build/jam/images/definitions/minimum
index 4cc2788..216109c 100644
--- a/build/jam/images/definitions/minimum
+++ b/build/jam/images/definitions/minimum
@@ -235,6 +235,7 @@ SYSTEM_ADD_ONS_FILE_SYSTEMS =
exfat ext2
fat
iso9660
+ log_overlay
ntfs
packagefs
reiserfs@x86
diff --git a/src/add-ons/kernel/file_systems/layers/log_overlay/log_overlay.cpp
b/src/add-ons/kernel/file_systems/layers/log_overlay/log_overlay.cpp
index c76cb7f..d49500e 100644
--- a/src/add-ons/kernel/file_systems/layers/log_overlay/log_overlay.cpp
+++ b/src/add-ons/kernel/file_systems/layers/log_overlay/log_overlay.cpp
@@ -29,20 +29,21 @@ static const char *kLogFilePrefix = "/var/log/log_overlay";
{ \
char _printBuffer[256]; \
int _printSize = snprintf(_printBuffer, sizeof(_printBuffer), \
- "%llu %ld %p: " format, system_time(),
find_thread(NULL), \
+ "%" B_PRId64 " %" B_PRId32 " %p: " format,
system_time(), \
+ find_thread(NULL), \
((fs_vnode *)vnode->private_node)->private_node, args);
\
if ((unsigned int)_printSize > sizeof(_printBuffer)) { \
_printBuffer[sizeof(_printBuffer) - 1] = '\n'; \
_printSize = sizeof(_printBuffer); \
} \
- write((int)volume->private_volume, _printBuffer, _printSize); \
+ write((int)(addr_t)volume->private_volume, _printBuffer,
_printSize); \
}

#define OVERLAY_CALL(op, params...) \
status_t result = B_UNSUPPORTED; \
fs_vnode *superVnode = (fs_vnode *)vnode->private_node; \
if (superVnode->ops->op != NULL) \
- result = superVnode->ops->op(volume->super_volume, superVnode,
params); \
+ result = superVnode->ops->op(volume->super_volume, superVnode,
params);


static status_t
@@ -57,7 +58,7 @@ overlay_put_vnode(fs_volume *volume, fs_vnode *vnode, bool
reenter)
reenter);
}

- DO_LOG("put_vnode result: 0x%08lx\n", result);
+ DO_LOG("put_vnode result: %#" B_PRIx32 "\n", result);
delete (fs_vnode *)vnode->private_node;
return result;
}
@@ -75,7 +76,7 @@ overlay_remove_vnode(fs_volume *volume, fs_vnode *vnode, bool
reenter)
reenter);
}

- DO_LOG("remove_vnode result: 0x%08lx\n", result);
+ DO_LOG("remove_vnode result: %#" B_PRIx32 "\n", result);
delete (fs_vnode *)vnode->private_node;
return result;
}
@@ -106,7 +107,7 @@ overlay_lookup(fs_volume *volume, fs_vnode *vnode, const
char *name, ino_t *id)
{
DO_LOG("lookup name: \"%s\"\n", name);
OVERLAY_CALL(lookup, name, id)
- DO_LOG("lookup result: 0x%08lx; id: %llu\n", result, *id);
+ DO_LOG("lookup result: %#" B_PRIx32 "; id: %" B_PRIdINO "\n", result,
*id);
return result;
}

@@ -115,9 +116,10 @@ static status_t
overlay_get_vnode_name(fs_volume *volume, fs_vnode *vnode, char *buffer,
size_t bufferSize)
{
- DO_LOG("get_vnode_name buffer: %p; buffer_size: %lu\n", buffer,
bufferSize);
+ DO_LOG("get_vnode_name buffer: %p; buffer_size: %" B_PRIuSIZE "\n",
buffer,
+ bufferSize);
OVERLAY_CALL(get_vnode_name, buffer, bufferSize)
- DO_LOG("get_vnode_name result: 0x%08lx; buffer: \"%s\"\n", result,
+ DO_LOG("get_vnode_name result: %#" B_PRIx32 "; buffer: \"%s\"\n",
result,
result == B_OK ? buffer : "unsafe");
return result;
}
@@ -143,10 +145,12 @@ static status_t
overlay_read_pages(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
const iovec *vecs, size_t count, size_t *numBytes)
{
- DO_LOG("read_pages cookie: %p; pos: %lld; vecs: %p; count: %lu;"
- " num_bytes: %lu\n", cookie, pos, vecs, count, *numBytes);
+ DO_LOG("read_pages cookie: %p; pos: %" B_PRIdOFF "; vecs: %p; count: %"
+ B_PRIuSIZE "; num_bytes: %" B_PRIuSIZE "\n", cookie, pos, vecs,
count,
+ *numBytes);
OVERLAY_CALL(read_pages, cookie, pos, vecs, count, numBytes)
- DO_LOG("read_pages result: 0x%08lx; num_bytes: %lu\n", result,
*numBytes);
+ DO_LOG("read_pages result: %#" B_PRIx32 "; num_bytes: %" B_PRIuSIZE
"\n",
+ result, *numBytes);
return result;
}

@@ -155,10 +159,12 @@ static status_t
overlay_write_pages(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t
pos,
const iovec *vecs, size_t count, size_t *numBytes)
{
- DO_LOG("write_pages cookie: %p; pos: %lld; vecs: %p; count: %lu;"
- " num_bytes: %lu\n", cookie, pos, vecs, count, *numBytes);
+ DO_LOG("write_pages cookie: %p; pos: %" B_PRIdOFF "; vecs: %p; count: %"
+ B_PRIuSIZE "; num_bytes: %" B_PRIuSIZE "\n", cookie, pos, vecs,
count,
+ *numBytes);
OVERLAY_CALL(write_pages, cookie, pos, vecs, count, numBytes)
- DO_LOG("write_pages result: 0x%08lx; num_bytes: %lu\n", result,
*numBytes);
+ DO_LOG("write_pages result: %#" B_PRIx32 "; num_bytes: %" B_PRIuSIZE
"\n",
+ result, *numBytes);
return result;
}

@@ -167,11 +173,12 @@ static status_t
overlay_io(fs_volume *volume, fs_vnode *vnode, void *cookie,
io_request *request)
{
- DO_LOG("io cookie: %p; request: %p (write: %s; offset: %lld; length:
%llu)"
- "\n", cookie, request, io_request_is_write(request) ? "yes" :
"no",
- io_request_offset(request), io_request_length(request));
+ DO_LOG("io cookie: %p; request: %p (write: %s; offset: %" B_PRIdOFF
+ "; length: %" B_PRIdOFF ")\n", cookie, request,
+ io_request_is_write(request) ? "yes" : "no",
io_request_offset(request),
+ io_request_length(request));
OVERLAY_CALL(io, cookie, request)
- DO_LOG("io result: 0x%08lx\n", result);
+ DO_LOG("io result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -182,7 +189,7 @@ overlay_cancel_io(fs_volume *volume, fs_vnode *vnode, void
*cookie,
{
DO_LOG("cancel_io cookie: %p; request: %p\n", cookie, request);
OVERLAY_CALL(cancel_io, cookie, request)
- DO_LOG("cancel_io result: 0x%08lx\n", result);
+ DO_LOG("cancel_io result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -191,10 +198,11 @@ static status_t
overlay_get_file_map(fs_volume *volume, fs_vnode *vnode, off_t offset,
size_t size, struct file_io_vec *vecs, size_t *count)
{
- DO_LOG("get_file_map offset: %lld; size: %lu; vecs: %p; count: %lu\n",
- offset, size, vecs, *count);
+ DO_LOG("get_file_map offset: %" B_PRIdOFF "; size: %" B_PRIuSIZE
+ "; vecs: %p; count: %" B_PRIuSIZE "\n", offset, size, vecs,
*count);
OVERLAY_CALL(get_file_map, offset, size, vecs, count)
- DO_LOG("get_file_map result: 0x%08lx; count: %lu\n", result, *count);
+ DO_LOG("get_file_map result: %#" B_PRIx32 "; count: %" B_PRIuSIZE "\n",
+ result, *count);
return result;
}

@@ -203,10 +211,10 @@ static status_t
overlay_ioctl(fs_volume *volume, fs_vnode *vnode, void *cookie, uint32 op,
void *buffer, size_t length)
{
- DO_LOG("ioctl cookie: %p; op: %lu; buffer: %p; size: %lu\n", cookie, op,
- buffer, length);
+ DO_LOG("ioctl cookie: %p; op: %" B_PRIu32 "; buffer: %p; size: %"
B_PRIuSIZE
+ "\n", cookie, op, buffer, length);
OVERLAY_CALL(ioctl, cookie, op, buffer, length)
- DO_LOG("ioctl result: 0x%08lx\n", result);
+ DO_LOG("ioctl result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -215,9 +223,9 @@ static status_t
overlay_set_flags(fs_volume *volume, fs_vnode *vnode, void *cookie,
int flags)
{
- DO_LOG("set_flags cookie: %p; flags: %d\n", cookie, flags);
+ DO_LOG("set_flags cookie: %p; flags: %#x\n", cookie, flags);
OVERLAY_CALL(set_flags, cookie, flags)
- DO_LOG("set_flags result: 0x%08lx\n", result);
+ DO_LOG("set_flags result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -226,10 +234,10 @@ static status_t
overlay_select(fs_volume *volume, fs_vnode *vnode, void *cookie, uint8 event,
selectsync *sync)
{
- DO_LOG("select cookie: %p; event: %u; selectsync: %p\n", cookie, event,
- sync);
+ DO_LOG("select cookie: %p; event: %" B_PRIu8 "; selectsync: %p\n",
cookie,
+ event, sync);
OVERLAY_CALL(select, cookie, event, sync)
- DO_LOG("select result: 0x%08lx\n", result);
+ DO_LOG("select result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -238,10 +246,10 @@ static status_t
overlay_deselect(fs_volume *volume, fs_vnode *vnode, void *cookie, uint8 event,
selectsync *sync)
{
- DO_LOG("deselect cookie: %p; event: %u; selectsync: %p\n", cookie,
event,
- sync);
+ DO_LOG("deselect cookie: %p; event: %" B_PRIu8 "; selectsync: %p\n",
cookie,
+ event, sync);
OVERLAY_CALL(deselect, cookie, event, sync)
- DO_LOG("deselect result: 0x%08lx\n", result);
+ DO_LOG("deselect result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -256,7 +264,7 @@ overlay_fsync(fs_volume *volume, fs_vnode *vnode)
if (superVnode->ops->fsync != NULL)
result = superVnode->ops->fsync(volume->super_volume,
superVnode);

- DO_LOG("fsync result: 0x%08lx\n", result);
+ DO_LOG("fsync result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -265,10 +273,12 @@ static status_t
overlay_read_symlink(fs_volume *volume, fs_vnode *vnode, char *buffer,
size_t *bufferSize)
{
- DO_LOG("read_symlink buffer: %p; buffer_size: %lu\n", buffer,
*bufferSize);
+ DO_LOG("read_symlink buffer: %p; buffer_size: %" B_PRIuSIZE "\n",
buffer,
+ *bufferSize);
OVERLAY_CALL(read_symlink, buffer, bufferSize)
- DO_LOG("read_symlink result: 0x%08lx; buffer_size: %lu; \"%.*s\"\n",
result,
- *bufferSize, result == B_OK ? (int)*bufferSize : 6,
+ DO_LOG("read_symlink result: %#" B_PRIx32 "; buffer_size: %" B_PRIuSIZE
+ "; \"%.*s\"\n", result, *bufferSize,
+ result == B_OK ? (int)*bufferSize : 6,
result == B_OK ? buffer : "unsafe");
return result;
}
@@ -278,10 +288,10 @@ static status_t
overlay_create_symlink(fs_volume *volume, fs_vnode *vnode, const char *name,
const char *path, int mode)
{
- DO_LOG("create_symlink name: \"%s\"; path: \"%s\"; mode: %u\n", name,
path,
+ DO_LOG("create_symlink name: \"%s\"; path: \"%s\"; mode: %#x\n", name,
path,
mode);
OVERLAY_CALL(create_symlink, name, path, mode)
- DO_LOG("create_symlink result: 0x%08lx\n", result);
+ DO_LOG("create_symlink result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -293,7 +303,7 @@ overlay_link(fs_volume *volume, fs_vnode *vnode, const char
*name,
DO_LOG("link name: \"%s\"; target: %p\n", name,
((fs_vnode *)target->private_node)->private_node);
OVERLAY_CALL(link, name, (fs_vnode *)target->private_node)
- DO_LOG("link result: 0x%08lx\n", result);
+ DO_LOG("link result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -303,7 +313,7 @@ overlay_unlink(fs_volume *volume, fs_vnode *vnode, const
char *name)
{
DO_LOG("unlink name: \"%s\"\n", name);
OVERLAY_CALL(unlink, name)
- DO_LOG("unlink result: 0x%08lx\n", result);
+ DO_LOG("unlink result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -315,7 +325,7 @@ overlay_rename(fs_volume *volume, fs_vnode *vnode,
DO_LOG("rename from_name: \"%s\"; to_dir: %p; to_name: \"%s\"\n",
fromName, ((fs_vnode *)toDir->private_node)->private_node,
toName);
OVERLAY_CALL(rename, fromName, (fs_vnode *)toDir->private_node, toName)
- DO_LOG("rename result: 0x%08lx\n", result);
+ DO_LOG("rename result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -323,9 +333,9 @@ overlay_rename(fs_volume *volume, fs_vnode *vnode,
static status_t
overlay_access(fs_volume *volume, fs_vnode *vnode, int mode)
{
- DO_LOG("access mode: %u\n", mode);
+ DO_LOG("access mode: %#x\n", mode);
OVERLAY_CALL(access, mode)
- DO_LOG("access result: 0x%08lx\n", result);
+ DO_LOG("access result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -336,12 +346,12 @@ overlay_read_stat(fs_volume *volume, fs_vnode *vnode,
struct stat *stat)
DO_LOG("read_stat stat: %p\n", stat);
OVERLAY_CALL(read_stat, stat)
if (result == B_OK) {
- DO_LOG("read_stat result: 0x%08lx; stat(dev: %lu; ino: %llu;
mode: %u;"
- " uid: %u; gid %u; size: %llu)\n", result, stat->st_dev,
- stat->st_ino, stat->st_mode, stat->st_uid, stat->st_gid,
- stat->st_size);
+ DO_LOG("read_stat result: %#" B_PRIx32 "; stat(dev: %" B_PRIdDEV
+ "; ino: %" B_PRIdINO "; mode: %#x; uid: %u; gid %u;
size: %"
+ B_PRIdOFF ")\n", result, stat->st_dev, stat->st_ino,
stat->st_mode,
+ stat->st_uid, stat->st_gid, stat->st_size);
} else
- DO_LOG("read_stat result: 0x%08lx\n", result);
+ DO_LOG("read_stat result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -350,9 +360,9 @@ static status_t
overlay_write_stat(fs_volume *volume, fs_vnode *vnode, const struct stat *stat,
uint32 statMask)
{
- DO_LOG("write_stat stat: %p; mask: %lu\n", stat, statMask);
+ DO_LOG("write_stat stat: %p; mask: %" B_PRIu32 "\n", stat, statMask);
OVERLAY_CALL(write_stat, stat, statMask)
- DO_LOG("write_stat result: 0x%08lx\n", result);
+ DO_LOG("write_stat result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -361,11 +371,11 @@ static status_t
overlay_create(fs_volume *volume, fs_vnode *vnode, const char *name,
int openMode, int perms, void **cookie, ino_t *newVnodeID)
{
- DO_LOG("create name: \"%s\"; open_mode: %u; perms: %u\n", name,
openMode,
+ DO_LOG("create name: \"%s\"; open_mode: %#x; perms: %#x\n", name,
openMode,
perms);
OVERLAY_CALL(create, name, openMode, perms, cookie, newVnodeID)
- DO_LOG("create result: 0x%08lx; cookie: %p; new_vnode_id: %llu\n",
result,
- *cookie, *newVnodeID);
+ DO_LOG("create result: %#" B_PRIx32 "; cookie: %p; new_vnode_id: %"
+ B_PRIdINO "\n", result, *cookie, *newVnodeID);
return result;
}

@@ -373,9 +383,9 @@ overlay_create(fs_volume *volume, fs_vnode *vnode, const
char *name,
static status_t
overlay_open(fs_volume *volume, fs_vnode *vnode, int openMode, void **cookie)
{
- DO_LOG("open open_mode: %u\n", openMode);
+ DO_LOG("open open_mode: %#x\n", openMode);
OVERLAY_CALL(open, openMode, cookie)
- DO_LOG("open result: 0x%08lx; cookie: %p\n", result, *cookie);
+ DO_LOG("open result: %#" B_PRIx32 "; cookie: %p\n", result, *cookie);
return result;
}

@@ -385,7 +395,7 @@ overlay_close(fs_volume *volume, fs_vnode *vnode, void
*cookie)
{
DO_LOG("close cookie %p\n", cookie);
OVERLAY_CALL(close, cookie)
- DO_LOG("close result: 0x%08lx\n", result);
+ DO_LOG("close result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -395,7 +405,7 @@ overlay_free_cookie(fs_volume *volume, fs_vnode *vnode,
void *cookie)
{
DO_LOG("free_cookie cookie %p\n", cookie);
OVERLAY_CALL(free_cookie, cookie)
- DO_LOG("free_cookie result: 0x%08lx\n", result);
+ DO_LOG("free_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -404,10 +414,11 @@ static status_t
overlay_read(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
void *buffer, size_t *length)
{
- DO_LOG("read cookie: %p; pos: %lld; buffer: %p; length: %lu\n", cookie,
pos,
- buffer, *length);
+ DO_LOG("read cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
+ B_PRIuSIZE "\n", cookie, pos, buffer, *length);
OVERLAY_CALL(read, cookie, pos, buffer, length)
- DO_LOG("read result: 0x%08lx; length: %lu\n", result, *length);
+ DO_LOG("read result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n", result,
+ *length);
return result;
}

@@ -416,10 +427,11 @@ static status_t
overlay_write(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
const void *buffer, size_t *length)
{
- DO_LOG("write cookie: %p; pos: %lld; buffer: %p; length: %lu\n", cookie,
- pos, buffer, *length);
+ DO_LOG("write cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length: %"
+ B_PRIuSIZE "\n", cookie, pos, buffer, *length);
OVERLAY_CALL(write, cookie, pos, buffer, length)
- DO_LOG("write result: 0x%08lx; length: %lu\n", result, *length);
+ DO_LOG("write result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n",
result,
+ *length);
return result;
}

@@ -428,9 +440,9 @@ static status_t
overlay_create_dir(fs_volume *volume, fs_vnode *vnode, const char *name,
int perms)
{
- DO_LOG("create_dir name: \"%s\"; perms: %u\n", name, perms);
+ DO_LOG("create_dir name: \"%s\"; perms: %#x\n", name, perms);
OVERLAY_CALL(create_dir, name, perms)
- DO_LOG("create_dir result: 0x%08lx\n", result);
+ DO_LOG("create_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -440,7 +452,7 @@ overlay_remove_dir(fs_volume *volume, fs_vnode *vnode,
const char *name)
{
DO_LOG("remove_dir name: \"%s\"\n", name);
OVERLAY_CALL(remove_dir, name)
- DO_LOG("remove_dir result: 0x%08lx\n", result);
+ DO_LOG("remove_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -450,7 +462,7 @@ overlay_open_dir(fs_volume *volume, fs_vnode *vnode, void
**cookie)
{
DO_LOG("%s\n", "open_dir");
OVERLAY_CALL(open_dir, cookie)
- DO_LOG("open_dir result: 0x%08lx; cookie: %p\n", result, *cookie);
+ DO_LOG("open_dir result: %#" B_PRIx32 "; cookie: %p\n", result,
*cookie);
return result;
}

@@ -460,7 +472,7 @@ overlay_close_dir(fs_volume *volume, fs_vnode *vnode, void
*cookie)
{
DO_LOG("close_dir cookie: %p\n", cookie);
OVERLAY_CALL(close_dir, cookie)
- DO_LOG("close_dir result: 0x%08lx\n", result);
+ DO_LOG("close_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -470,7 +482,7 @@ overlay_free_dir_cookie(fs_volume *volume, fs_vnode *vnode,
void *cookie)
{
DO_LOG("free_dir_cookie cookie: %p\n", cookie);
OVERLAY_CALL(free_dir_cookie, cookie)
- DO_LOG("free_dir_cookie result: 0x%08lx\n", result);
+ DO_LOG("free_dir_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -479,10 +491,11 @@ static status_t
overlay_read_dir(fs_volume *volume, fs_vnode *vnode, void *cookie,
struct dirent *buffer, size_t bufferSize, uint32 *num)
{
- DO_LOG("read_dir cookie: %p; buffer: %p; buffer_size: %lu\n", cookie,
- buffer, bufferSize);
+ DO_LOG("read_dir cookie: %p; buffer: %p; buffer_size: %" B_PRIuSIZE
"\n",
+ cookie, buffer, bufferSize);
OVERLAY_CALL(read_dir, cookie, buffer, bufferSize, num);
- DO_LOG("read_dir result: 0x%08lx; num: %lu\n", result, *num);
+ DO_LOG("read_dir result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n", result,
+ *num);
return result;
}

@@ -492,7 +505,7 @@ overlay_rewind_dir(fs_volume *volume, fs_vnode *vnode, void
*cookie)
{
DO_LOG("rewind_dir cookie: %p\n", cookie);
OVERLAY_CALL(rewind_dir, cookie)
- DO_LOG("rewind_dir result: 0x%08lx\n", result);
+ DO_LOG("rewind_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -502,7 +515,8 @@ overlay_open_attr_dir(fs_volume *volume, fs_vnode *vnode,
void **cookie)
{
DO_LOG("%s\n", "open_attr_dir");
OVERLAY_CALL(open_attr_dir, cookie)
- DO_LOG("open_attr_dir result: 0x%08lx; cookie: %p\n", result, *cookie);
+ DO_LOG("open_attr_dir result: %#" B_PRIx32 "; cookie: %p\n", result,
+ *cookie);
return result;
}

@@ -512,7 +526,7 @@ overlay_close_attr_dir(fs_volume *volume, fs_vnode *vnode,
void *cookie)
{
DO_LOG("close_attr_dir cookie: %p\n", cookie);
OVERLAY_CALL(close_attr_dir, cookie)
- DO_LOG("close_attr_dir result: 0x%08lx\n", result);
+ DO_LOG("close_attr_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -522,7 +536,7 @@ overlay_free_attr_dir_cookie(fs_volume *volume, fs_vnode
*vnode, void *cookie)
{
DO_LOG("free_attr_dir_cookie cookie: %p\n", cookie);
OVERLAY_CALL(free_attr_dir_cookie, cookie)
- DO_LOG("free_attr_dir_cookie result: 0x%08lx\n", result);
+ DO_LOG("free_attr_dir_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -531,10 +545,11 @@ static status_t
overlay_read_attr_dir(fs_volume *volume, fs_vnode *vnode, void *cookie,
struct dirent *buffer, size_t bufferSize, uint32 *num)
{
- DO_LOG("read_attr_dir cookie: %p; buffer: %p; buffer_size: %lu\n",
cookie,
- buffer, bufferSize);
+ DO_LOG("read_attr_dir cookie: %p; buffer: %p; buffer_size: %" B_PRIuSIZE
+ "\n", cookie, buffer, bufferSize);
OVERLAY_CALL(read_attr_dir, cookie, buffer, bufferSize, num);
- DO_LOG("read_attr_dir result: 0x%08lx; num: %lu\n", result, *num);
+ DO_LOG("read_attr_dir result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n",
result,
+ *num);
return result;
}

@@ -544,7 +559,7 @@ overlay_rewind_attr_dir(fs_volume *volume, fs_vnode *vnode,
void *cookie)
{
DO_LOG("rewind_attr_dir cookie: %p\n", cookie);
OVERLAY_CALL(rewind_attr_dir, cookie)
- DO_LOG("rewind_attr_dir result: 0x%08lx\n", result);
+ DO_LOG("rewind_attr_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -553,10 +568,10 @@ static status_t
overlay_create_attr(fs_volume *volume, fs_vnode *vnode, const char *name,
uint32 type, int openMode, void **cookie)
{
- DO_LOG("create_attr name: \"%s\"; type: 0x%08lx; open_mode: %u\n", name,
- type, openMode);
+ DO_LOG("create_attr name: \"%s\"; type: %#" B_PRIx32 "; open_mode:
%#x\n",
+ name, type, openMode);
OVERLAY_CALL(create_attr, name, type, openMode, cookie)
- DO_LOG("create_attr result: 0x%08lx; cookie: %p\n", result, *cookie);
+ DO_LOG("create_attr result: %#" B_PRIx32 "; cookie: %p\n", result,
*cookie);
return result;
}

@@ -565,9 +580,9 @@ static status_t
overlay_open_attr(fs_volume *volume, fs_vnode *vnode, const char *name,
int openMode, void **cookie)
{
- DO_LOG("open_attr name: \"%s\"; open_mode: %u\n", name, openMode);
+ DO_LOG("open_attr name: \"%s\"; open_mode: %#x\n", name, openMode);
OVERLAY_CALL(open_attr, name, openMode, cookie)
- DO_LOG("open_attr result: 0x%08lx; cookie: %p\n", result, *cookie);
+ DO_LOG("open_attr result: %#" B_PRIx32 "; cookie: %p\n", result,
*cookie);
return result;
}

@@ -577,7 +592,7 @@ overlay_close_attr(fs_volume *volume, fs_vnode *vnode, void
*cookie)
{
DO_LOG("close_attr cookie: %p\n", cookie);
OVERLAY_CALL(close_attr, cookie)
- DO_LOG("close_attr result: 0x%08lx\n", result);
+ DO_LOG("close_attr result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -587,7 +602,7 @@ overlay_free_attr_cookie(fs_volume *volume, fs_vnode
*vnode, void *cookie)
{
DO_LOG("free_attr_cookie cookie: %p\n", cookie);
OVERLAY_CALL(free_attr_cookie, cookie)
- DO_LOG("free_attr_cookie result: 0x%08lx\n", result);
+ DO_LOG("free_attr_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -596,10 +611,11 @@ static status_t
overlay_read_attr(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
void *buffer, size_t *length)
{
- DO_LOG("read_attr cookie: %p; pos: %lld; buffer: %p; length: %lu\n",
cookie,
- pos, buffer, *length);
+ DO_LOG("read_attr cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length:
%"
+ B_PRIuSIZE "\n", cookie, pos, buffer, *length);
OVERLAY_CALL(read_attr, cookie, pos, buffer, length)
- DO_LOG("read_attr result: 0x%08lx; length: %lu\n", result, *length);
+ DO_LOG("read_attr result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n",
+ result, *length);
return result;
}

@@ -608,10 +624,11 @@ static status_t
overlay_write_attr(fs_volume *volume, fs_vnode *vnode, void *cookie, off_t pos,
const void *buffer, size_t *length)
{
- DO_LOG("write_attr cookie: %p; pos: %lld; buffer: %p; length: %lu\n",
- cookie, pos, buffer, *length);
+ DO_LOG("write_attr cookie: %p; pos: %" B_PRIdOFF "; buffer: %p; length:
%"
+ B_PRIuSIZE "\n", cookie, pos, buffer, *length);
OVERLAY_CALL(write_attr, cookie, pos, buffer, length)
- DO_LOG("write_attr result: 0x%08lx; length: %lu\n", result, *length);
+ DO_LOG("write_attr result: %#" B_PRIx32 "; length: %" B_PRIuSIZE "\n",
+ result, *length);
return result;
}

@@ -623,12 +640,13 @@ overlay_read_attr_stat(fs_volume *volume, fs_vnode
*vnode, void *cookie,
DO_LOG("read_attr_stat cookie: %p; stat: %p\n", cookie, stat);
OVERLAY_CALL(read_attr_stat, cookie, stat)
if (result == B_OK) {
- DO_LOG("read_attr_stat result: 0x%08lx; stat(dev: %lu; ino:
%llu;"
- " mode: %u; uid: %u; gid %u; size: %llu; type:
0x%08lx)\n", result,
+ DO_LOG("read_attr_stat result: %#" B_PRIx32 "; stat(dev: %"
B_PRIdDEV
+ "; ino: %" B_PRIdINO "; mode: %#x; uid: %u; gid %u;
size: %"
+ B_PRIdOFF "; type: %#" B_PRIx32 ")\n", result,
stat->st_dev, stat->st_ino, stat->st_mode, stat->st_uid,
stat->st_gid, stat->st_size, stat->st_type);
} else
- DO_LOG("read_attr_stat result: 0x%08lx\n", result);
+ DO_LOG("read_attr_stat result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -637,10 +655,10 @@ static status_t
overlay_write_attr_stat(fs_volume *volume, fs_vnode *vnode, void *cookie,
const struct stat *stat, int statMask)
{
- DO_LOG("write_attr_stat cookie: %p; stat: %p; mask: %u\n", cookie, stat,
+ DO_LOG("write_attr_stat cookie: %p; stat: %p; mask: %#x\n", cookie,
stat,
statMask);
OVERLAY_CALL(write_attr_stat, cookie, stat, statMask)
- DO_LOG("write_attr_stat result: 0x%08lx\n", result);
+ DO_LOG("write_attr_stat result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -653,7 +671,7 @@ overlay_rename_attr(fs_volume *volume, fs_vnode *vnode,
fromName, ((fs_vnode *)toVnode->private_node)->private_node,
toName);
OVERLAY_CALL(rename_attr, fromName, (fs_vnode *)toVnode->private_node,
toName)
- DO_LOG("rename_attr result: 0x%08lx\n", result);
+ DO_LOG("rename_attr result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -663,7 +681,7 @@ overlay_remove_attr(fs_volume *volume, fs_vnode *vnode,
const char *name)
{
DO_LOG("remove_attr name: \"%s\"\n", name);
OVERLAY_CALL(remove_attr, name)
- DO_LOG("remove_attr result: 0x%08lx\n", result);
+ DO_LOG("remove_attr result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -673,12 +691,13 @@ overlay_create_special_node(fs_volume *volume, fs_vnode
*vnode,
const char *name, fs_vnode *subVnode, mode_t mode, uint32 flags,
fs_vnode *_superVnode, ino_t *nodeID)
{
- DO_LOG("create_special_node name: \"%s\"; sub_vnode: %p; mode: %u;"
- " flags: %lu\n", name, subVnode->private_node, mode, flags);
+ DO_LOG("create_special_node name: \"%s\"; sub_vnode: %p; mode: %#x;"
+ " flags: %" B_PRIu32 "\n", name, subVnode->private_node, mode,
flags);
OVERLAY_CALL(create_special_node, name, (fs_vnode
*)subVnode->private_node,
mode, flags, _superVnode, nodeID)
- DO_LOG("create_special_node result: 0x%08lx; super_vnode: %p;"
- " node_id: %llu\n", result, _superVnode->private_node, *nodeID);
+ DO_LOG("create_special_node result: %#" B_PRIx32 "; super_vnode: %p;"
+ " node_id: %" B_PRIdINO "\n", result, _superVnode->private_node,
+ *nodeID);
return result;
}

@@ -767,19 +786,19 @@ static fs_vnode_ops sOverlayVnodeOps = {
{ \
char _printBuffer[256]; \
int _printSize = snprintf(_printBuffer, sizeof(_printBuffer), \
- "%llu %ld %p: " format, system_time(),
find_thread(NULL), \
- volume->super_volume, args); \
+ "%" B_PRId64 " %" B_PRId32 " %p: " format,
system_time(), \
+ find_thread(NULL), volume->super_volume, args); \
if ((unsigned int)_printSize > sizeof(_printBuffer)) { \
_printBuffer[sizeof(_printBuffer) - 1] = '\n'; \
_printSize = sizeof(_printBuffer); \
} \
- write((int)volume->private_volume, _printBuffer, _printSize); \
+ write((int)(addr_t)volume->private_volume, _printBuffer,
_printSize); \
}

#define OVERLAY_VOLUME_CALL(op, params...) \
status_t result = B_UNSUPPORTED; \
if (volume->super_volume->ops->op != NULL) \
- result = volume->super_volume->ops->op(volume->super_volume,
params); \
+ result = volume->super_volume->ops->op(volume->super_volume,
params);


static status_t
@@ -790,7 +809,7 @@ overlay_unmount(fs_volume *volume)
&& volume->super_volume->ops->unmount != NULL)
volume->super_volume->ops->unmount(volume->super_volume);

- close((int)volume->private_volume);
+ close((int)(addr_t)volume->private_volume);
return B_OK;
}

@@ -800,12 +819,13 @@ overlay_read_fs_info(fs_volume *volume, struct fs_info
*info)
{
DO_VOLUME_LOG("%s\n", "read_fs_info");
OVERLAY_VOLUME_CALL(read_fs_info, info)
- DO_VOLUME_LOG("read_fs_info result: 0x%08lx; info(dev: %lu; root: %llu;"
- " flags: %lu; block_size: %lld; io_size: %lld; total_blocks:
%lld;"
- " free_blocks: %lld; total_nodes: %lld; free_nodes: %lld;"
- " device_name: \"%s\"; volume_name: \"%s\"; fsh_name:
\"%s\")\n",
- result, info->dev, info->root, info->flags, info->block_size,
- info->io_size, info->total_blocks, info->free_blocks,
+ DO_VOLUME_LOG("read_fs_info result: %#" B_PRIx32 "; info(dev: %"
B_PRIdDEV
+ "; root: %" B_PRIdINO "; flags: %#" B_PRIx32 "; block_size: %"
B_PRIdOFF
+ "; io_size: %" B_PRIdOFF "; total_blocks: %" B_PRIdOFF
+ "; free_blocks: %" B_PRIdOFF "; total_nodes: %" B_PRIdOFF
+ "; free_nodes: %" B_PRIdOFF "; device_name: \"%s\";
volume_name: \"%s\""
+ "; fsh_name: \"%s\")\n", result, info->dev, info->root,
info->flags,
+ info->block_size, info->io_size, info->total_blocks,
info->free_blocks,
info->total_nodes, info->free_nodes, info->device_name,
info->volume_name, info->fsh_name);
return result;
@@ -816,9 +836,9 @@ static status_t
overlay_write_fs_info(fs_volume *volume, const struct fs_info *info,
uint32 mask)
{
- DO_VOLUME_LOG("write_fs_info info: %p; mask: %lu\n", info, mask);
+ DO_VOLUME_LOG("write_fs_info info: %p; mask: %#" B_PRIx32 "\n", info,
mask);
OVERLAY_VOLUME_CALL(write_fs_info, info, mask)
- DO_VOLUME_LOG("write_fs_info result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("write_fs_info result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -830,7 +850,7 @@ overlay_sync(fs_volume *volume)
status_t result = B_UNSUPPORTED;
if (volume->super_volume->ops->sync != NULL)
result = volume->super_volume->ops->sync(volume->super_volume);
- DO_VOLUME_LOG("sync result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("sync result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -839,8 +859,9 @@ static status_t
overlay_get_vnode(fs_volume *volume, ino_t id, fs_vnode *vnode, int *type,
uint32 *flags, bool reenter)
{
- DO_VOLUME_LOG("get_vnode id: %llu; vnode: %p; type*: %p; flags*: %p;"
- " reenter: %d\n", id, vnode, type, flags, reenter);
+ DO_VOLUME_LOG("get_vnode id: %" B_PRIdINO "; vnode: %p; type*: %p;"
+ " flags*: %p; reenter: %s\n", id, vnode, type, flags,
+ reenter ? "yes" : "no");

if (volume->super_volume->ops->get_vnode == NULL) {
DO_VOLUME_LOG("get_vnode %s\n", "not supported");
@@ -856,7 +877,7 @@ overlay_get_vnode(fs_volume *volume, ino_t id, fs_vnode
*vnode, int *type,
status_t result =
volume->super_volume->ops->get_vnode(volume->super_volume,
id, superVnode, type, flags, reenter);
if (result != B_OK) {
- DO_VOLUME_LOG("get_vnode result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("get_vnode result: %#" B_PRIx32 "\n", result);
delete superVnode;
return result;
}
@@ -864,7 +885,7 @@ overlay_get_vnode(fs_volume *volume, ino_t id, fs_vnode
*vnode, int *type,
vnode->private_node = superVnode;
vnode->ops = &sOverlayVnodeOps;

- DO_VOLUME_LOG("get_vnode result: 0x%08lx; super_vnode: %p\n", result,
+ DO_VOLUME_LOG("get_vnode result: %#" B_PRIx32 "; super_vnode: %p\n",
result,
superVnode->private_node);
return B_OK;
}
@@ -875,7 +896,7 @@ overlay_open_index_dir(fs_volume *volume, void **cookie)
{
DO_VOLUME_LOG("%s\n", "open_index_dir");
OVERLAY_VOLUME_CALL(open_index_dir, cookie)
- DO_VOLUME_LOG("open_index_dir result: 0x%08lx; cookie: %p\n", result,
+ DO_VOLUME_LOG("open_index_dir result: %#" B_PRIx32 "; cookie: %p\n",
result,
*cookie);
return result;
}
@@ -886,7 +907,7 @@ overlay_close_index_dir(fs_volume *volume, void *cookie)
{
DO_VOLUME_LOG("close_index_dir cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(close_index_dir, cookie)
- DO_VOLUME_LOG("close_index_dir result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("close_index_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -896,7 +917,7 @@ overlay_free_index_dir_cookie(fs_volume *volume, void
*cookie)
{
DO_VOLUME_LOG("free_index_dir_cookie cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(free_index_dir_cookie, cookie)
- DO_VOLUME_LOG("free_index_dir_cookie result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("free_index_dir_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -905,10 +926,11 @@ static status_t
overlay_read_index_dir(fs_volume *volume, void *cookie, struct dirent *buffer,
size_t bufferSize, uint32 *num)
{
- DO_VOLUME_LOG("read_index_dir cookie: %p; buffer: %p; buffer_size:
%lu\n",
- cookie, buffer, bufferSize);
+ DO_VOLUME_LOG("read_index_dir cookie: %p; buffer: %p; buffer_size: %"
+ B_PRIuSIZE "\n", cookie, buffer, bufferSize);
OVERLAY_VOLUME_CALL(read_index_dir, cookie, buffer, bufferSize, num)
- DO_VOLUME_LOG("read_index_dir result: 0x%08lx; num: %lu\n", result,
*num);
+ DO_VOLUME_LOG("read_index_dir result: %#" B_PRIx32 "; num: %" B_PRIu32
"\n",
+ result, *num);
return result;
}

@@ -918,7 +940,7 @@ overlay_rewind_index_dir(fs_volume *volume, void *cookie)
{
DO_VOLUME_LOG("rewind_index_dir cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(rewind_index_dir, cookie)
- DO_VOLUME_LOG("rewind_index_dir result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("rewind_index_dir result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -927,10 +949,10 @@ static status_t
overlay_create_index(fs_volume *volume, const char *name, uint32 type,
uint32 flags)
{
- DO_VOLUME_LOG("create_index name: \"%s\"; type: %lu; flags: %lu\n",
name,
- type, flags);
+ DO_VOLUME_LOG("create_index name: \"%s\"; type: %#" B_PRIx32
+ "; flags: %#" B_PRIx32 "\n", name, type, flags);
OVERLAY_VOLUME_CALL(create_index, name, type, flags)
- DO_VOLUME_LOG("create_index result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("create_index result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -940,7 +962,7 @@ overlay_remove_index(fs_volume *volume, const char *name)
{
DO_VOLUME_LOG("remove_index name: \"%s\"\n", name);
OVERLAY_VOLUME_CALL(remove_index, name)
- DO_VOLUME_LOG("remove_index result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("remove_index result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -951,13 +973,13 @@ overlay_read_index_stat(fs_volume *volume, const char
*name, struct stat *stat)
DO_VOLUME_LOG("read_index_stat name: \"%s\"; stat: %p\n", name, stat);
OVERLAY_VOLUME_CALL(read_index_stat, name, stat)
if (result == B_OK) {
- DO_VOLUME_LOG("read_index_stat result: 0x%08lx; stat(dev: %lu;"
- " ino: %llu; mode: %u; uid: %u; gid %u; size: %llu;"
- " type: 0x%08lx)\n", result, stat->st_dev, stat->st_ino,
- stat->st_mode, stat->st_uid, stat->st_gid,
stat->st_size,
- stat->st_type);
+ DO_VOLUME_LOG("read_index_stat result: %#" B_PRIx32 ";
stat(dev: %"
+ B_PRIdDEV "; ino: %" B_PRIdINO "; mode: %#x; uid: %u;
gid %u;"
+ " size: %" B_PRIdOFF "; type: %#" B_PRIx32 ")\n",
result,
+ stat->st_dev, stat->st_ino, stat->st_mode, stat->st_uid,
+ stat->st_gid, stat->st_size, stat->st_type);
} else
- DO_VOLUME_LOG("read_index_stat result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("read_index_stat result: %#" B_PRIx32 "\n",
result);
return result;
}

@@ -966,10 +988,11 @@ static status_t
overlay_open_query(fs_volume *volume, const char *query, uint32 flags,
port_id port, uint32 token, void **cookie)
{
- DO_VOLUME_LOG("open_query query: \"%s\"; flags: %lu; port: %ld;"
- " token: %lu\n", query, flags, port, token);
+ DO_VOLUME_LOG("open_query query: \"%s\"; flags: %#" B_PRIx32 "; port: %"
+ B_PRId32 "; token: %" B_PRIu32 "\n", query, flags, port, token);
OVERLAY_VOLUME_CALL(open_query, query, flags, port, token, cookie)
- DO_VOLUME_LOG("open_query result: 0x%08lx; cookie: %p\n", result,
*cookie);
+ DO_VOLUME_LOG("open_query result: %#" B_PRIx32 "; cookie: %p\n", result,
+ *cookie);
return result;
}

@@ -979,7 +1002,7 @@ overlay_close_query(fs_volume *volume, void *cookie)
{
DO_VOLUME_LOG("close_query cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(close_query, cookie)
- DO_VOLUME_LOG("close_query result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("close_query result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -989,7 +1012,7 @@ overlay_free_query_cookie(fs_volume *volume, void *cookie)
{
DO_VOLUME_LOG("free_query_cookie cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(free_query_cookie, cookie)
- DO_VOLUME_LOG("free_query_cookie result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("free_query_cookie result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -998,10 +1021,11 @@ static status_t
overlay_read_query(fs_volume *volume, void *cookie, struct dirent *buffer,
size_t bufferSize, uint32 *num)
{
- DO_VOLUME_LOG("read_query cookie: %p; buffer: %p; buffer_size: %lu\n",
- cookie, buffer, bufferSize);
+ DO_VOLUME_LOG("read_query cookie: %p; buffer: %p; buffer_size: %"
+ B_PRIuSIZE "\n", cookie, buffer, bufferSize);
OVERLAY_VOLUME_CALL(read_query, cookie, buffer, bufferSize, num)
- DO_VOLUME_LOG("read_query result: 0x%08lx; num: %lu\n", result, *num);
+ DO_VOLUME_LOG("read_query result: %#" B_PRIx32 "; num: %" B_PRIu32 "\n",
+ result, *num);
return result;
}

@@ -1011,7 +1035,7 @@ overlay_rewind_query(fs_volume *volume, void *cookie)
{
DO_VOLUME_LOG("rewind_query cookie: %p\n", cookie);
OVERLAY_VOLUME_CALL(rewind_query, cookie)
- DO_VOLUME_LOG("rewind_query result: 0x%08lx\n", result);
+ DO_VOLUME_LOG("rewind_query result: %#" B_PRIx32 "\n", result);
return result;
}

@@ -1096,7 +1120,7 @@ overlay_mount(fs_volume *volume, const char *device,
uint32 flags,
if (fd < 0)
return errno;

- volume->private_volume = (void *)fd;
+ volume->private_volume = (void *)(addr_t)fd;
volume->ops = &sOverlayVolumeOps;
return B_OK;
}


Other related posts:

  • » [haiku-commits] haiku: hrev49370 - src/add-ons/kernel/file_systems/layers/log_overlay - mmlr