OK, thanks. Next, I will/should continue to analyse the performance issue for 9pfs when users drop into a long directory path under bash shell.
Although I am not quite sure, hope I can find the root cause within this month (2014-03-31). Welcome any suggestions, discussions, and completions for it. Thanks. On 03/07/2014 11:16 PM, Aneesh Kumar K.V wrote: > From: Chen Gang <gang.chen.5...@gmail.com> > > When path is truncated by PATH_MAX limitation, it causes QEMU to access > incorrect file. So use original full path instead of PATH_MAX within > 9pfs (need check/process ENOMEM for related memory allocation). > > The related test: > > - Environments (for qemu-devel): > > - Host is under fedora17 desktop with ext4fs: > > qemu-system-x86_64 -hda test.img -m 1024 \ > -net nic,vlan=4,model=virtio,macaddr=00:16:35:AF:94:04 \ > -net tap,vlan=4,ifname=tap4,script=no,downscript=no \ > -device virtio-9p-pci,id=fs0,fsdev=fsdev0,mount_tag=hostshare \ > -fsdev local,security_model=passthrough,id=fsdev0,\ > path=/upstream/vm/data/share/1234567890abcdefghijklmnopqrstuvwxyz\ > ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmnopqrstuvwxyz\ > ABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111111111\ > 1111111111111111111111111111111111111111111111111111222222222222\ > 2222222222222222222222222222222222222222222222222222222222222222\ > 2222222222222222222222222222222222233333333333333333333333333333\ > 3333333333333333333333333333333333 > > - Guest is ubuntu12 server with 9pfs. > > mount -t 9p -o trans=virtio,version=9p2000.L hostshare /share > > - Limitations: > > full path limitation is PATH_MAX (4096B include nul) under Linux. > file/dir node name maximized length is 256 (include nul) under ext4. > > - Special test: > > Under host, modify the file: "/upstream/vm/data/share/1234567890abcdefg\ > hijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890acdefghijklmno\ > pqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890/111111111111111111111\ > 111111111111111111111111111111111111111111111111111111111122222222222\ > 222222222222222222222222222222222222222222222222222222222222222222222\ > 222222222222222222222222222222233333333333333333333333333333333333333\ > 3333333333333333333333333/4444444444444444444444444444444444444444444\ > 444444444444444444444444444444444444444444444444444444444444444444444\ > 444444444444444444444444444444444444444444444444444444444444444444444\ > 444444444444444444444444444444444444444/55555555555555555555555555555\ > 555555555555555555555555555555555555555555555555555555555555555555555\ > 555555555555555555555555555555555555555555555555555555555555555555555\ > 555555555555555555555555555555555555555555555555555555555555555555555\ > 55555555/666666666666666666666666666666666666666666666666666666666666\ > 666666666666666666666666666666666666666666666666666666666666666666666\ > 666666666666666666666666666666666666666666666666666666666666666666666\ > 666666666666666666666/77777777777777777777777777777777777777777777777\ > 777777777777777777777777777777777777777777777777777777777777777777777\ > 777777777777777777777777777777777777777777777777777777777777777777777\ > 77777777777777777777777777777777777777777777777777777777777/888888888\ > 888888888888888888888888888888888888888888888888888888888888888888888\ > 888888888888888888888888888888888888888888888888888888888888888888888\ > 888888888888888888888888888888888888888888888888888888888888888888888\ > 888888888/99999999999999999999999999999999999999999999999999999999999\ > 999999999999999999999999999999999999999999999999999999999999999999999\ > 999999999999999999999999999999999999999999999999999999999999999999999\ > 99999999999999999999999999999999999999999/000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000000000000000000000000\ > 000000000000000000000000000000000000000000000000/aaaaaaaaaaaaaaaaaaaa\ > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\ > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\ > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbb\ > bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\ > bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\ > bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ccccccccc\ > ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\ > ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\ > ccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc\ > cccccccccc/dddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\ > ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\ > ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd\ > dddddddddddddddddddddd/eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\ > eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\ > eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee\ > eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee/fffffffffffffff\ > fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\ > fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff\ > ffffffffffffffffffffffffffffffffffffffffffffffffffffffffff/gggggggggg\ > ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\ > ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\ > ggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg\ > ggggggggggggggggggggggg/iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\ > iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\ > iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii\ > iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii/jjjjjjjjjjjjj\ > jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj\ > jjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjj/ppppppppppppppppppppp\ > ppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp\ > ppppppppppppppppppppppppppppppppppppppp/test1234567890file.log" > (need enter dir firstly, then modify file, or can not open it). > > Under guest, still allow modify "test1234567890file.log" (will generate > "test123456" file with contents). > > After apply this patch, can not open "test1234567890file.log" under guest > (permission denied). > > - Common test: > > All are still OK after apply this path. > > "mkdir -p", "create/open file/dir", "modify file/dir", "rm file/dir". > change various mount point paths under host and/or guest. > > Signed-off-by: Chen Gang <gang.chen.5...@gmail.com> > Signed-off-by: Aneesh Kumar K.V <aneesh.ku...@linux.vnet.ibm.com> > --- > hw/9pfs/cofs.c | 48 +++++-- > hw/9pfs/virtio-9p-handle.c | 9 +- > hw/9pfs/virtio-9p-local.c | 287 > +++++++++++++++++++++++++++-------------- > hw/9pfs/virtio-9p-posix-acl.c | 52 ++++++-- > hw/9pfs/virtio-9p-xattr-user.c | 27 +++- > hw/9pfs/virtio-9p-xattr.c | 9 +- > hw/9pfs/virtio-9p-xattr.h | 27 +++- > hw/9pfs/virtio-9p.h | 6 +- > 8 files changed, 316 insertions(+), 149 deletions(-) > > diff --git a/hw/9pfs/cofs.c b/hw/9pfs/cofs.c > index 389105074852..0aba70ad792f 100644 > --- a/hw/9pfs/cofs.c > +++ b/hw/9pfs/cofs.c > @@ -17,35 +17,55 @@ > #include "block/coroutine.h" > #include "virtio-9p-coth.h" > > +static ssize_t __readlink(V9fsState *s, V9fsPath *path, V9fsString *buf) > +{ > + ssize_t len, maxlen = PATH_MAX; > + > + buf->data = g_malloc(PATH_MAX); > + for (;;) { > + len = s->ops->readlink(&s->ctx, path, buf->data, maxlen); > + if (len < 0) { > + g_free(buf->data); > + buf->data = NULL; > + buf->size = 0; > + break; > + } else if (len == maxlen) { > + /* > + * We dodn't have space to put the NULL or we have more > + * to read. Increase the size and try again > + */ > + maxlen *= 2; > + g_free(buf->data); > + buf->data = g_malloc(maxlen); > + continue; > + } > + /* > + * Null terminate the readlink output > + */ > + buf->data[len] = '\0'; > + buf->size = len; > + break; > + } > + return len; > +} > + > int v9fs_co_readlink(V9fsPDU *pdu, V9fsPath *path, V9fsString *buf) > { > int err; > - ssize_t len; > V9fsState *s = pdu->s; > > if (v9fs_request_cancelled(pdu)) { > return -EINTR; > } > - buf->data = g_malloc(PATH_MAX); > v9fs_path_read_lock(s); > v9fs_co_run_in_worker( > { > - len = s->ops->readlink(&s->ctx, path, > - buf->data, PATH_MAX - 1); > - if (len > -1) { > - buf->size = len; > - buf->data[len] = 0; > - err = 0; > - } else { > + err = __readlink(s, path, buf); > + if (err < 0) { > err = -errno; > } > }); > v9fs_path_unlock(s); > - if (err) { > - g_free(buf->data); > - buf->data = NULL; > - buf->size = 0; > - } > return err; > } > > diff --git a/hw/9pfs/virtio-9p-handle.c b/hw/9pfs/virtio-9p-handle.c > index 17002a3d2867..4b79cefd135e 100644 > --- a/hw/9pfs/virtio-9p-handle.c > +++ b/hw/9pfs/virtio-9p-handle.c > @@ -498,7 +498,7 @@ static int handle_lremovexattr(FsContext *ctx, V9fsPath > *fs_path, > static int handle_name_to_path(FsContext *ctx, V9fsPath *dir_path, > const char *name, V9fsPath *target) > { > - char buffer[PATH_MAX]; > + char *buffer; > struct file_handle *fh; > int dirfd, ret, mnt_id; > struct handle_data *data = (struct handle_data *)ctx->private; > @@ -513,7 +513,9 @@ static int handle_name_to_path(FsContext *ctx, V9fsPath > *dir_path, > dirfd = open_by_handle(data->mountfd, dir_path->data, O_PATH); > } else { > /* relative to export root */ > - dirfd = open(rpath(ctx, ".", buffer), O_DIRECTORY); > + buffer = rpath(ctx, "."); > + dirfd = open(buffer, O_DIRECTORY); > + g_free(buffer); > } > if (dirfd < 0) { > return dirfd; > @@ -521,7 +523,7 @@ static int handle_name_to_path(FsContext *ctx, V9fsPath > *dir_path, > fh = g_malloc(sizeof(struct file_handle) + data->handle_bytes); > fh->handle_bytes = data->handle_bytes; > /* add a "./" at the beginning of the path */ > - snprintf(buffer, PATH_MAX, "./%s", name); > + buffer = g_strdup_printf("./%s", name); > /* flag = 0 imply don't follow symlink */ > ret = name_to_handle(dirfd, buffer, fh, &mnt_id, 0); > if (!ret) { > @@ -531,6 +533,7 @@ static int handle_name_to_path(FsContext *ctx, V9fsPath > *dir_path, > g_free(fh); > } > close(dirfd); > + g_free(buffer); > return ret; > } > > diff --git a/hw/9pfs/virtio-9p-local.c b/hw/9pfs/virtio-9p-local.c > index dc615a4d0fa4..56b302c122b6 100644 > --- a/hw/9pfs/virtio-9p-local.c > +++ b/hw/9pfs/virtio-9p-local.c > @@ -42,18 +42,18 @@ > > #define VIRTFS_META_DIR ".virtfs_metadata" > > -static const char *local_mapped_attr_path(FsContext *ctx, > - const char *path, char *buffer) > +static char *local_mapped_attr_path(FsContext *ctx, const char *path) > { > char *dir_name; > char *tmp_path = g_strdup(path); > char *base_name = basename(tmp_path); > + char *buffer; > > /* NULL terminate the directory */ > dir_name = tmp_path; > *(base_name - 1) = '\0'; > > - snprintf(buffer, PATH_MAX, "%s/%s/%s/%s", > + buffer = g_strdup_printf("%s/%s/%s/%s", > ctx->fs_root, dir_name, VIRTFS_META_DIR, base_name); > g_free(tmp_path); > return buffer; > @@ -92,10 +92,11 @@ static void local_mapped_file_attr(FsContext *ctx, const > char *path, > { > FILE *fp; > char buf[ATTR_MAX]; > - char attr_path[PATH_MAX]; > + char *attr_path; > > - local_mapped_attr_path(ctx, path, attr_path); > + attr_path = local_mapped_attr_path(ctx, path); > fp = local_fopen(attr_path, "r"); > + g_free(attr_path); > if (!fp) { > return; > } > @@ -118,12 +119,13 @@ static void local_mapped_file_attr(FsContext *ctx, > const char *path, > static int local_lstat(FsContext *fs_ctx, V9fsPath *fs_path, struct stat > *stbuf) > { > int err; > - char buffer[PATH_MAX]; > + char *buffer; > char *path = fs_path->data; > > - err = lstat(rpath(fs_ctx, path, buffer), stbuf); > + buffer = rpath(fs_ctx, path); > + err = lstat(buffer, stbuf); > if (err) { > - return err; > + goto err_out; > } > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > /* Actual credentials are part of extended attrs */ > @@ -131,41 +133,42 @@ static int local_lstat(FsContext *fs_ctx, V9fsPath > *fs_path, struct stat *stbuf) > gid_t tmp_gid; > mode_t tmp_mode; > dev_t tmp_dev; > - if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.uid", > &tmp_uid, > - sizeof(uid_t)) > 0) { > + if (getxattr(buffer, "user.virtfs.uid", &tmp_uid, sizeof(uid_t)) > > 0) { > stbuf->st_uid = tmp_uid; > } > - if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.gid", > &tmp_gid, > - sizeof(gid_t)) > 0) { > + if (getxattr(buffer, "user.virtfs.gid", &tmp_gid, sizeof(gid_t)) > > 0) { > stbuf->st_gid = tmp_gid; > } > - if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.mode", > + if (getxattr(buffer, "user.virtfs.mode", > &tmp_mode, sizeof(mode_t)) > 0) { > stbuf->st_mode = tmp_mode; > } > - if (getxattr(rpath(fs_ctx, path, buffer), "user.virtfs.rdev", > &tmp_dev, > - sizeof(dev_t)) > 0) { > + if (getxattr(buffer, "user.virtfs.rdev", &tmp_dev, sizeof(dev_t)) > > 0) { > stbuf->st_rdev = tmp_dev; > } > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > local_mapped_file_attr(fs_ctx, path, stbuf); > } > + > +err_out: > + g_free(buffer); > return err; > } > > static int local_create_mapped_attr_dir(FsContext *ctx, const char *path) > { > int err; > - char attr_dir[PATH_MAX]; > + char *attr_dir; > char *tmp_path = g_strdup(path); > > - snprintf(attr_dir, PATH_MAX, "%s/%s/%s", > + attr_dir = g_strdup_printf("%s/%s/%s", > ctx->fs_root, dirname(tmp_path), VIRTFS_META_DIR); > > err = mkdir(attr_dir, 0700); > if (err < 0 && errno == EEXIST) { > err = 0; > } > + g_free(attr_dir); > g_free(tmp_path); > return err; > } > @@ -176,10 +179,11 @@ static int local_set_mapped_file_attr(FsContext *ctx, > FILE *fp; > int ret = 0; > char buf[ATTR_MAX]; > - char attr_path[PATH_MAX]; > + char *attr_path; > int uid = -1, gid = -1, mode = -1, rdev = -1; > > - fp = local_fopen(local_mapped_attr_path(ctx, path, attr_path), "r"); > + attr_path = local_mapped_attr_path(ctx, path); > + fp = local_fopen(attr_path, "r"); > if (!fp) { > goto create_map_file; > } > @@ -241,6 +245,7 @@ update_map_file: > fclose(fp); > > err_out: > + g_free(attr_path); > return ret; > } > > @@ -282,36 +287,43 @@ static int local_set_xattr(const char *path, FsCred > *credp) > static int local_post_create_passthrough(FsContext *fs_ctx, const char *path, > FsCred *credp) > { > - char buffer[PATH_MAX]; > + char *buffer; > > - if (lchown(rpath(fs_ctx, path, buffer), credp->fc_uid, > - credp->fc_gid) < 0) { > + buffer = rpath(fs_ctx, path); > + if (lchown(buffer, credp->fc_uid, credp->fc_gid) < 0) { > /* > * If we fail to change ownership and if we are > * using security model none. Ignore the error > */ > if ((fs_ctx->export_flags & V9FS_SEC_MASK) != V9FS_SM_NONE) { > - return -1; > + goto err; > } > } > > - if (chmod(rpath(fs_ctx, path, buffer), credp->fc_mode & 07777) < 0) { > - return -1; > + if (chmod(buffer, credp->fc_mode & 07777) < 0) { > + goto err; > } > + > + g_free(buffer); > return 0; > +err: > + g_free(buffer); > + return -1; > } > > static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath *fs_path, > char *buf, size_t bufsz) > { > ssize_t tsize = -1; > - char buffer[PATH_MAX]; > + char *buffer; > char *path = fs_path->data; > > if ((fs_ctx->export_flags & V9FS_SM_MAPPED) || > (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE)) { > int fd; > - fd = open(rpath(fs_ctx, path, buffer), O_RDONLY | O_NOFOLLOW); > + buffer = rpath(fs_ctx, path); > + fd = open(buffer, O_RDONLY | O_NOFOLLOW); > + g_free(buffer); > if (fd == -1) { > return -1; > } > @@ -322,7 +334,9 @@ static ssize_t local_readlink(FsContext *fs_ctx, V9fsPath > *fs_path, > return tsize; > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - tsize = readlink(rpath(fs_ctx, path, buffer), buf, bufsz); > + buffer = rpath(fs_ctx, path); > + tsize = readlink(buffer, buf, bufsz); > + g_free(buffer); > } > return tsize; > } > @@ -340,20 +354,24 @@ static int local_closedir(FsContext *ctx, > V9fsFidOpenState *fs) > static int local_open(FsContext *ctx, V9fsPath *fs_path, > int flags, V9fsFidOpenState *fs) > { > - char buffer[PATH_MAX]; > + char *buffer; > char *path = fs_path->data; > > - fs->fd = open(rpath(ctx, path, buffer), flags | O_NOFOLLOW); > + buffer = rpath(ctx, path); > + fs->fd = open(buffer, flags | O_NOFOLLOW); > + g_free(buffer); > return fs->fd; > } > > static int local_opendir(FsContext *ctx, > V9fsPath *fs_path, V9fsFidOpenState *fs) > { > - char buffer[PATH_MAX]; > + char *buffer; > char *path = fs_path->data; > > - fs->dir = opendir(rpath(ctx, path, buffer)); > + buffer = rpath(ctx, path); > + fs->dir = opendir(buffer); > + g_free(buffer); > if (!fs->dir) { > return -1; > } > @@ -441,18 +459,23 @@ static ssize_t local_pwritev(FsContext *ctx, > V9fsFidOpenState *fs, > > static int local_chmod(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret = -1; > char *path = fs_path->data; > > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > - return local_set_xattr(rpath(fs_ctx, path, buffer), credp); > + buffer = rpath(fs_ctx, path); > + ret = local_set_xattr(buffer, credp); > + g_free(buffer); > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > return local_set_mapped_file_attr(fs_ctx, path, credp); > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - return chmod(rpath(fs_ctx, path, buffer), credp->fc_mode); > + buffer = rpath(fs_ctx, path); > + ret = chmod(buffer, credp->fc_mode); > + g_free(buffer); > } > - return -1; > + return ret; > } > > static int local_mknod(FsContext *fs_ctx, V9fsPath *dir_path, > @@ -462,7 +485,7 @@ static int local_mknod(FsContext *fs_ctx, V9fsPath > *dir_path, > int err = -1; > int serrno = 0; > V9fsString fullname; > - char buffer[PATH_MAX]; > + char *buffer; > > v9fs_string_init(&fullname); > v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); > @@ -470,21 +493,23 @@ static int local_mknod(FsContext *fs_ctx, V9fsPath > *dir_path, > > /* Determine the security model */ > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > - err = mknod(rpath(fs_ctx, path, buffer), > - SM_LOCAL_MODE_BITS|S_IFREG, 0); > + buffer = rpath(fs_ctx, path); > + err = mknod(buffer, SM_LOCAL_MODE_BITS|S_IFREG, 0); > if (err == -1) { > + g_free(buffer); > goto out; > } > - err = local_set_xattr(rpath(fs_ctx, path, buffer), credp); > + err = local_set_xattr(buffer, credp); > if (err == -1) { > serrno = errno; > goto err_end; > } > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > > - err = mknod(rpath(fs_ctx, path, buffer), > - SM_LOCAL_MODE_BITS|S_IFREG, 0); > + buffer = rpath(fs_ctx, path); > + err = mknod(buffer, SM_LOCAL_MODE_BITS|S_IFREG, 0); > if (err == -1) { > + g_free(buffer); > goto out; > } > err = local_set_mapped_file_attr(fs_ctx, path, credp); > @@ -494,9 +519,10 @@ static int local_mknod(FsContext *fs_ctx, V9fsPath > *dir_path, > } > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - err = mknod(rpath(fs_ctx, path, buffer), credp->fc_mode, > - credp->fc_rdev); > + buffer = rpath(fs_ctx, path); > + err = mknod(buffer, credp->fc_mode, credp->fc_rdev); > if (err == -1) { > + g_free(buffer); > goto out; > } > err = local_post_create_passthrough(fs_ctx, path, credp); > @@ -508,8 +534,9 @@ static int local_mknod(FsContext *fs_ctx, V9fsPath > *dir_path, > goto out; > > err_end: > - remove(rpath(fs_ctx, path, buffer)); > + remove(buffer); > errno = serrno; > + g_free(buffer); > out: > v9fs_string_free(&fullname); > return err; > @@ -522,7 +549,7 @@ static int local_mkdir(FsContext *fs_ctx, V9fsPath > *dir_path, > int err = -1; > int serrno = 0; > V9fsString fullname; > - char buffer[PATH_MAX]; > + char *buffer; > > v9fs_string_init(&fullname); > v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); > @@ -530,19 +557,23 @@ static int local_mkdir(FsContext *fs_ctx, V9fsPath > *dir_path, > > /* Determine the security model */ > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > - err = mkdir(rpath(fs_ctx, path, buffer), SM_LOCAL_DIR_MODE_BITS); > + buffer = rpath(fs_ctx, path); > + err = mkdir(buffer, SM_LOCAL_DIR_MODE_BITS); > if (err == -1) { > + g_free(buffer); > goto out; > } > credp->fc_mode = credp->fc_mode|S_IFDIR; > - err = local_set_xattr(rpath(fs_ctx, path, buffer), credp); > + err = local_set_xattr(buffer, credp); > if (err == -1) { > serrno = errno; > goto err_end; > } > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > - err = mkdir(rpath(fs_ctx, path, buffer), SM_LOCAL_DIR_MODE_BITS); > + buffer = rpath(fs_ctx, path); > + err = mkdir(buffer, SM_LOCAL_DIR_MODE_BITS); > if (err == -1) { > + g_free(buffer); > goto out; > } > credp->fc_mode = credp->fc_mode|S_IFDIR; > @@ -553,8 +584,10 @@ static int local_mkdir(FsContext *fs_ctx, V9fsPath > *dir_path, > } > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - err = mkdir(rpath(fs_ctx, path, buffer), credp->fc_mode); > + buffer = rpath(fs_ctx, path); > + err = mkdir(buffer, credp->fc_mode); > if (err == -1) { > + g_free(buffer); > goto out; > } > err = local_post_create_passthrough(fs_ctx, path, credp); > @@ -566,8 +599,9 @@ static int local_mkdir(FsContext *fs_ctx, V9fsPath > *dir_path, > goto out; > > err_end: > - remove(rpath(fs_ctx, path, buffer)); > + remove(buffer); > errno = serrno; > + g_free(buffer); > out: > v9fs_string_free(&fullname); > return err; > @@ -626,7 +660,7 @@ static int local_open2(FsContext *fs_ctx, V9fsPath > *dir_path, const char *name, > int err = -1; > int serrno = 0; > V9fsString fullname; > - char buffer[PATH_MAX]; > + char *buffer; > > /* > * Mark all the open to not follow symlinks > @@ -639,21 +673,25 @@ static int local_open2(FsContext *fs_ctx, V9fsPath > *dir_path, const char *name, > > /* Determine the security model */ > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > - fd = open(rpath(fs_ctx, path, buffer), flags, SM_LOCAL_MODE_BITS); > + buffer = rpath(fs_ctx, path); > + fd = open(buffer, flags, SM_LOCAL_MODE_BITS); > if (fd == -1) { > + g_free(buffer); > err = fd; > goto out; > } > credp->fc_mode = credp->fc_mode|S_IFREG; > /* Set cleint credentials in xattr */ > - err = local_set_xattr(rpath(fs_ctx, path, buffer), credp); > + err = local_set_xattr(buffer, credp); > if (err == -1) { > serrno = errno; > goto err_end; > } > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > - fd = open(rpath(fs_ctx, path, buffer), flags, SM_LOCAL_MODE_BITS); > + buffer = rpath(fs_ctx, path); > + fd = open(buffer, flags, SM_LOCAL_MODE_BITS); > if (fd == -1) { > + g_free(buffer); > err = fd; > goto out; > } > @@ -666,8 +704,10 @@ static int local_open2(FsContext *fs_ctx, V9fsPath > *dir_path, const char *name, > } > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - fd = open(rpath(fs_ctx, path, buffer), flags, credp->fc_mode); > + buffer = rpath(fs_ctx, path); > + fd = open(buffer, flags, credp->fc_mode); > if (fd == -1) { > + g_free(buffer); > err = fd; > goto out; > } > @@ -683,8 +723,9 @@ static int local_open2(FsContext *fs_ctx, V9fsPath > *dir_path, const char *name, > > err_end: > close(fd); > - remove(rpath(fs_ctx, path, buffer)); > + remove(buffer); > errno = serrno; > + g_free(buffer); > out: > v9fs_string_free(&fullname); > return err; > @@ -698,7 +739,7 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > int serrno = 0; > char *newpath; > V9fsString fullname; > - char buffer[PATH_MAX]; > + char *buffer; > > v9fs_string_init(&fullname); > v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name); > @@ -708,10 +749,10 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > int fd; > ssize_t oldpath_size, write_size; > - fd = open(rpath(fs_ctx, newpath, buffer), > - O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, > - SM_LOCAL_MODE_BITS); > + buffer = rpath(fs_ctx, newpath); > + fd = open(buffer, O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, > SM_LOCAL_MODE_BITS); > if (fd == -1) { > + g_free(buffer); > err = fd; > goto out; > } > @@ -730,7 +771,7 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > close(fd); > /* Set cleint credentials in symlink's xattr */ > credp->fc_mode = credp->fc_mode|S_IFLNK; > - err = local_set_xattr(rpath(fs_ctx, newpath, buffer), credp); > + err = local_set_xattr(buffer, credp); > if (err == -1) { > serrno = errno; > goto err_end; > @@ -738,10 +779,10 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > int fd; > ssize_t oldpath_size, write_size; > - fd = open(rpath(fs_ctx, newpath, buffer), > - O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, > - SM_LOCAL_MODE_BITS); > + buffer = rpath(fs_ctx, newpath); > + fd = open(buffer, O_CREAT|O_EXCL|O_RDWR|O_NOFOLLOW, > SM_LOCAL_MODE_BITS); > if (fd == -1) { > + g_free(buffer); > err = fd; > goto out; > } > @@ -767,12 +808,13 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > } > } else if ((fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - err = symlink(oldpath, rpath(fs_ctx, newpath, buffer)); > + buffer = rpath(fs_ctx, newpath); > + err = symlink(oldpath, buffer); > if (err) { > + g_free(buffer); > goto out; > } > - err = lchown(rpath(fs_ctx, newpath, buffer), credp->fc_uid, > - credp->fc_gid); > + err = lchown(buffer, credp->fc_uid, credp->fc_gid); > if (err == -1) { > /* > * If we fail to change ownership and if we are > @@ -788,8 +830,9 @@ static int local_symlink(FsContext *fs_ctx, const char > *oldpath, > goto out; > > err_end: > - remove(rpath(fs_ctx, newpath, buffer)); > + remove(buffer); > errno = serrno; > + g_free(buffer); > out: > v9fs_string_free(&fullname); > return err; > @@ -800,13 +843,16 @@ static int local_link(FsContext *ctx, V9fsPath *oldpath, > { > int ret; > V9fsString newpath; > - char buffer[PATH_MAX], buffer1[PATH_MAX]; > + char *buffer, *buffer1; > > v9fs_string_init(&newpath); > v9fs_string_sprintf(&newpath, "%s/%s", dirpath->data, name); > > - ret = link(rpath(ctx, oldpath->data, buffer), > - rpath(ctx, newpath.data, buffer1)); > + buffer = rpath(ctx, oldpath->data); > + buffer1 = rpath(ctx, newpath.data); > + ret = link(buffer, buffer1); > + g_free(buffer); > + g_free(buffer1); > > /* now link the virtfs_metadata files */ > if (!ret && (ctx->export_flags & V9FS_SM_MAPPED_FILE)) { > @@ -815,8 +861,11 @@ static int local_link(FsContext *ctx, V9fsPath *oldpath, > if (ret < 0) { > goto err_out; > } > - ret = link(local_mapped_attr_path(ctx, oldpath->data, buffer), > - local_mapped_attr_path(ctx, newpath.data, buffer1)); > + buffer = local_mapped_attr_path(ctx, oldpath->data); > + buffer1 = local_mapped_attr_path(ctx, newpath.data); > + ret = link(buffer, buffer1); > + g_free(buffer); > + g_free(buffer1); > if (ret < 0 && errno != ENOENT) { > goto err_out; > } > @@ -828,17 +877,21 @@ err_out: > > static int local_truncate(FsContext *ctx, V9fsPath *fs_path, off_t size) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret; > char *path = fs_path->data; > > - return truncate(rpath(ctx, path, buffer), size); > + buffer = rpath(ctx, path); > + ret = truncate(buffer, size); > + g_free(buffer); > + return ret; > } > > static int local_rename(FsContext *ctx, const char *oldpath, > const char *newpath) > { > int err; > - char buffer[PATH_MAX], buffer1[PATH_MAX]; > + char *buffer, *buffer1; > > if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { > err = local_create_mapped_attr_dir(ctx, newpath); > @@ -846,50 +899,69 @@ static int local_rename(FsContext *ctx, const char > *oldpath, > return err; > } > /* rename the .virtfs_metadata files */ > - err = rename(local_mapped_attr_path(ctx, oldpath, buffer), > - local_mapped_attr_path(ctx, newpath, buffer1)); > + buffer = local_mapped_attr_path(ctx, oldpath); > + buffer1 = local_mapped_attr_path(ctx, newpath); > + err = rename(buffer, buffer1); > + g_free(buffer); > + g_free(buffer1); > if (err < 0 && errno != ENOENT) { > return err; > } > } > - return rename(rpath(ctx, oldpath, buffer), rpath(ctx, newpath, buffer1)); > + > + buffer = rpath(ctx, oldpath); > + buffer1 = rpath(ctx, newpath); > + err = rename(buffer, buffer1); > + g_free(buffer); > + g_free(buffer1); > + return err; > } > > static int local_chown(FsContext *fs_ctx, V9fsPath *fs_path, FsCred *credp) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret = -1; > char *path = fs_path->data; > > if ((credp->fc_uid == -1 && credp->fc_gid == -1) || > (fs_ctx->export_flags & V9FS_SM_PASSTHROUGH) || > (fs_ctx->export_flags & V9FS_SM_NONE)) { > - return lchown(rpath(fs_ctx, path, buffer), > - credp->fc_uid, credp->fc_gid); > + buffer = rpath(fs_ctx, path); > + ret = lchown(buffer, credp->fc_uid, credp->fc_gid); > + g_free(buffer); > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED) { > - return local_set_xattr(rpath(fs_ctx, path, buffer), credp); > + buffer = rpath(fs_ctx, path); > + ret = local_set_xattr(buffer, credp); > + g_free(buffer); > } else if (fs_ctx->export_flags & V9FS_SM_MAPPED_FILE) { > return local_set_mapped_file_attr(fs_ctx, path, credp); > } > - return -1; > + return ret; > } > > static int local_utimensat(FsContext *s, V9fsPath *fs_path, > const struct timespec *buf) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret; > char *path = fs_path->data; > > - return qemu_utimens(rpath(s, path, buffer), buf); > + buffer = rpath(s, path); > + ret = qemu_utimens(buffer, buf); > + g_free(buffer); > + return ret; > } > > static int local_remove(FsContext *ctx, const char *path) > { > int err; > struct stat stbuf; > - char buffer[PATH_MAX]; > + char *buffer; > > if (ctx->export_flags & V9FS_SM_MAPPED_FILE) { > - err = lstat(rpath(ctx, path, buffer), &stbuf); > + buffer = rpath(ctx, path); > + err = lstat(buffer, &stbuf); > + g_free(buffer); > if (err) { > goto err_out; > } > @@ -898,9 +970,10 @@ static int local_remove(FsContext *ctx, const char *path) > * directory > */ > if (S_ISDIR(stbuf.st_mode)) { > - snprintf(buffer, ARRAY_SIZE(buffer), "%s/%s/%s", > - ctx->fs_root, path, VIRTFS_META_DIR); > + buffer = g_strdup_printf("%s/%s/%s", ctx->fs_root, > + path, VIRTFS_META_DIR); > err = remove(buffer); > + g_free(buffer); > if (err < 0 && errno != ENOENT) { > /* > * We didn't had the .virtfs_metadata file. May be file > created > @@ -913,7 +986,9 @@ static int local_remove(FsContext *ctx, const char *path) > * Now remove the name from parent directory > * .virtfs_metadata directory > */ > - err = remove(local_mapped_attr_path(ctx, path, buffer)); > + buffer = local_mapped_attr_path(ctx, path); > + err = remove(buffer); > + g_free(buffer); > if (err < 0 && errno != ENOENT) { > /* > * We didn't had the .virtfs_metadata file. May be file created > @@ -922,7 +997,10 @@ static int local_remove(FsContext *ctx, const char *path) > goto err_out; > } > } > - return remove(rpath(ctx, path, buffer)); > + > + buffer = rpath(ctx, path); > + err = remove(buffer); > + g_free(buffer); > err_out: > return err; > } > @@ -947,10 +1025,14 @@ static int local_fsync(FsContext *ctx, int fid_type, > > static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs > *stbuf) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret; > char *path = fs_path->data; > > - return statfs(rpath(s, path, buffer), stbuf); > + buffer = rpath(s, path); > + ret = statfs(buffer, stbuf); > + g_free(buffer); > + return ret; > } > > static ssize_t local_lgetxattr(FsContext *ctx, V9fsPath *fs_path, > @@ -1023,7 +1105,7 @@ static int local_unlinkat(FsContext *ctx, V9fsPath *dir, > { > int ret; > V9fsString fullname; > - char buffer[PATH_MAX]; > + char *buffer; > > v9fs_string_init(&fullname); > > @@ -1034,9 +1116,10 @@ static int local_unlinkat(FsContext *ctx, V9fsPath > *dir, > * If directory remove .virtfs_metadata contained in the > * directory > */ > - snprintf(buffer, ARRAY_SIZE(buffer), "%s/%s/%s", ctx->fs_root, > - fullname.data, VIRTFS_META_DIR); > + buffer = g_strdup_printf("%s/%s/%s", ctx->fs_root, > + fullname.data, VIRTFS_META_DIR); > ret = remove(buffer); > + g_free(buffer); > if (ret < 0 && errno != ENOENT) { > /* > * We didn't had the .virtfs_metadata file. May be file > created > @@ -1049,7 +1132,9 @@ static int local_unlinkat(FsContext *ctx, V9fsPath *dir, > * Now remove the name from parent directory > * .virtfs_metadata directory. > */ > - ret = remove(local_mapped_attr_path(ctx, fullname.data, buffer)); > + buffer = local_mapped_attr_path(ctx, fullname.data); > + ret = remove(buffer); > + g_free(buffer); > if (ret < 0 && errno != ENOENT) { > /* > * We didn't had the .virtfs_metadata file. May be file created > @@ -1059,7 +1144,9 @@ static int local_unlinkat(FsContext *ctx, V9fsPath *dir, > } > } > /* Remove the name finally */ > - ret = remove(rpath(ctx, fullname.data, buffer)); > + buffer = rpath(ctx, fullname.data); > + ret = remove(buffer); > + g_free(buffer); > > err_out: > v9fs_string_free(&fullname); > diff --git a/hw/9pfs/virtio-9p-posix-acl.c b/hw/9pfs/virtio-9p-posix-acl.c > index 339c5ecae441..803d9d94f3b8 100644 > --- a/hw/9pfs/virtio-9p-posix-acl.c > +++ b/hw/9pfs/virtio-9p-posix-acl.c > @@ -26,8 +26,13 @@ > static ssize_t mp_pacl_getxattr(FsContext *ctx, const char *path, > const char *name, void *value, size_t size) > { > - char buffer[PATH_MAX]; > - return lgetxattr(rpath(ctx, path, buffer), MAP_ACL_ACCESS, value, size); > + char *buffer; > + ssize_t ret; > + > + buffer = rpath(ctx, path); > + ret = lgetxattr(buffer, MAP_ACL_ACCESS, value, size); > + g_free(buffer); > + return ret; > } > > static ssize_t mp_pacl_listxattr(FsContext *ctx, const char *path, > @@ -52,17 +57,23 @@ static ssize_t mp_pacl_listxattr(FsContext *ctx, const > char *path, > static int mp_pacl_setxattr(FsContext *ctx, const char *path, const char > *name, > void *value, size_t size, int flags) > { > - char buffer[PATH_MAX]; > - return lsetxattr(rpath(ctx, path, buffer), MAP_ACL_ACCESS, value, > - size, flags); > + char *buffer; > + int ret; > + > + buffer = rpath(ctx, path); > + ret = lsetxattr(buffer, MAP_ACL_ACCESS, value, size, flags); > + g_free(buffer); > + return ret; > } > > static int mp_pacl_removexattr(FsContext *ctx, > const char *path, const char *name) > { > int ret; > - char buffer[PATH_MAX]; > - ret = lremovexattr(rpath(ctx, path, buffer), MAP_ACL_ACCESS); > + char *buffer; > + > + buffer = rpath(ctx, path); > + ret = lremovexattr(buffer, MAP_ACL_ACCESS); > if (ret == -1 && errno == ENODATA) { > /* > * We don't get ENODATA error when trying to remove a > @@ -72,14 +83,20 @@ static int mp_pacl_removexattr(FsContext *ctx, > errno = 0; > ret = 0; > } > + g_free(buffer); > return ret; > } > > static ssize_t mp_dacl_getxattr(FsContext *ctx, const char *path, > const char *name, void *value, size_t size) > { > - char buffer[PATH_MAX]; > - return lgetxattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT, value, size); > + char *buffer; > + ssize_t ret; > + > + buffer = rpath(ctx, path); > + ret = lgetxattr(buffer, MAP_ACL_DEFAULT, value, size); > + g_free(buffer); > + return ret; > } > > static ssize_t mp_dacl_listxattr(FsContext *ctx, const char *path, > @@ -104,17 +121,23 @@ static ssize_t mp_dacl_listxattr(FsContext *ctx, const > char *path, > static int mp_dacl_setxattr(FsContext *ctx, const char *path, const char > *name, > void *value, size_t size, int flags) > { > - char buffer[PATH_MAX]; > - return lsetxattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT, value, > - size, flags); > + char *buffer; > + int ret; > + > + buffer = rpath(ctx, path); > + ret = lsetxattr(buffer, MAP_ACL_DEFAULT, value, size, flags); > + g_free(buffer); > + return ret; > } > > static int mp_dacl_removexattr(FsContext *ctx, > const char *path, const char *name) > { > int ret; > - char buffer[PATH_MAX]; > - ret = lremovexattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT); > + char *buffer; > + > + buffer = rpath(ctx, path); > + ret = lremovexattr(buffer, MAP_ACL_DEFAULT); > if (ret == -1 && errno == ENODATA) { > /* > * We don't get ENODATA error when trying to remove a > @@ -124,6 +147,7 @@ static int mp_dacl_removexattr(FsContext *ctx, > errno = 0; > ret = 0; > } > + g_free(buffer); > return ret; > } > > diff --git a/hw/9pfs/virtio-9p-xattr-user.c b/hw/9pfs/virtio-9p-xattr-user.c > index e0c92ebf9e5d..46133e06dbdf 100644 > --- a/hw/9pfs/virtio-9p-xattr-user.c > +++ b/hw/9pfs/virtio-9p-xattr-user.c > @@ -21,7 +21,9 @@ > static ssize_t mp_user_getxattr(FsContext *ctx, const char *path, > const char *name, void *value, size_t size) > { > - char buffer[PATH_MAX]; > + char *buffer; > + ssize_t ret; > + > if (strncmp(name, "user.virtfs.", 12) == 0) { > /* > * Don't allow fetch of user.virtfs namesapce > @@ -30,7 +32,10 @@ static ssize_t mp_user_getxattr(FsContext *ctx, const char > *path, > errno = ENOATTR; > return -1; > } > - return lgetxattr(rpath(ctx, path, buffer), name, value, size); > + buffer = rpath(ctx, path); > + ret = lgetxattr(buffer, name, value, size); > + g_free(buffer); > + return ret; > } > > static ssize_t mp_user_listxattr(FsContext *ctx, const char *path, > @@ -69,7 +74,9 @@ static ssize_t mp_user_listxattr(FsContext *ctx, const char > *path, > static int mp_user_setxattr(FsContext *ctx, const char *path, const char > *name, > void *value, size_t size, int flags) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret; > + > if (strncmp(name, "user.virtfs.", 12) == 0) { > /* > * Don't allow fetch of user.virtfs namesapce > @@ -78,13 +85,18 @@ static int mp_user_setxattr(FsContext *ctx, const char > *path, const char *name, > errno = EACCES; > return -1; > } > - return lsetxattr(rpath(ctx, path, buffer), name, value, size, flags); > + buffer = rpath(ctx, path); > + ret = lsetxattr(buffer, name, value, size, flags); > + g_free(buffer); > + return ret; > } > > static int mp_user_removexattr(FsContext *ctx, > const char *path, const char *name) > { > - char buffer[PATH_MAX]; > + char *buffer; > + int ret; > + > if (strncmp(name, "user.virtfs.", 12) == 0) { > /* > * Don't allow fetch of user.virtfs namesapce > @@ -93,7 +105,10 @@ static int mp_user_removexattr(FsContext *ctx, > errno = EACCES; > return -1; > } > - return lremovexattr(rpath(ctx, path, buffer), name); > + buffer = rpath(ctx, path); > + ret = lremovexattr(buffer, name); > + g_free(buffer); > + return ret; > } > > XattrOperations mapped_user_xattr = { > diff --git a/hw/9pfs/virtio-9p-xattr.c b/hw/9pfs/virtio-9p-xattr.c > index 3fae557a84ff..07183887c5ee 100644 > --- a/hw/9pfs/virtio-9p-xattr.c > +++ b/hw/9pfs/virtio-9p-xattr.c > @@ -67,21 +67,24 @@ ssize_t v9fs_list_xattr(FsContext *ctx, const char *path, > void *value, size_t vsize) > { > ssize_t size = 0; > - char buffer[PATH_MAX]; > + char *buffer; > void *ovalue = value; > XattrOperations *xops; > char *orig_value, *orig_value_start; > ssize_t xattr_len, parsed_len = 0, attr_len; > > /* Get the actual len */ > - xattr_len = llistxattr(rpath(ctx, path, buffer), value, 0); > + buffer = rpath(ctx, path); > + xattr_len = llistxattr(buffer, value, 0); > if (xattr_len <= 0) { > + g_free(buffer); > return xattr_len; > } > > /* Now fetch the xattr and find the actual size */ > orig_value = g_malloc(xattr_len); > - xattr_len = llistxattr(rpath(ctx, path, buffer), orig_value, xattr_len); > + xattr_len = llistxattr(buffer, orig_value, xattr_len); > + g_free(buffer); > > /* store the orig pointer */ > orig_value_start = orig_value; > diff --git a/hw/9pfs/virtio-9p-xattr.h b/hw/9pfs/virtio-9p-xattr.h > index 41cc6cbc7ba0..327b32b5aa9e 100644 > --- a/hw/9pfs/virtio-9p-xattr.h > +++ b/hw/9pfs/virtio-9p-xattr.h > @@ -54,23 +54,38 @@ ssize_t pt_listxattr(FsContext *ctx, const char *path, > char *name, void *value, > static inline ssize_t pt_getxattr(FsContext *ctx, const char *path, > const char *name, void *value, size_t size) > { > - char buffer[PATH_MAX]; > - return lgetxattr(rpath(ctx, path, buffer), name, value, size); > + char *buffer; > + ssize_t ret; > + > + buffer = rpath(ctx, path); > + ret = lgetxattr(buffer, name, value, size); > + g_free(buffer); > + return ret; > } > > static inline int pt_setxattr(FsContext *ctx, const char *path, > const char *name, void *value, > size_t size, int flags) > { > - char buffer[PATH_MAX]; > - return lsetxattr(rpath(ctx, path, buffer), name, value, size, flags); > + char *buffer; > + int ret; > + > + buffer = rpath(ctx, path); > + ret = lsetxattr(buffer, name, value, size, flags); > + g_free(buffer); > + return ret; > } > > static inline int pt_removexattr(FsContext *ctx, > const char *path, const char *name) > { > - char buffer[PATH_MAX]; > - return lremovexattr(rpath(ctx, path, buffer), name); > + char *buffer; > + int ret; > + > + buffer = rpath(ctx, path); > + ret = lremovexattr(path, name); > + g_free(buffer); > + return ret; > } > > static inline ssize_t notsup_getxattr(FsContext *ctx, const char *path, > diff --git a/hw/9pfs/virtio-9p.h b/hw/9pfs/virtio-9p.h > index 1d6eedb7d8bc..2c3603aed0d0 100644 > --- a/hw/9pfs/virtio-9p.h > +++ b/hw/9pfs/virtio-9p.h > @@ -6,6 +6,7 @@ > #include <sys/time.h> > #include <utime.h> > #include <sys/resource.h> > +#include <glib.h> > #include "hw/virtio/virtio.h" > #include "fsdev/file-op-9p.h" > #include "fsdev/virtio-9p-marshal.h" > @@ -112,10 +113,9 @@ enum p9_proto_version { > > #define FID_REFERENCED 0x1 > #define FID_NON_RECLAIMABLE 0x2 > -static inline const char *rpath(FsContext *ctx, const char *path, char > *buffer) > +static inline char *rpath(FsContext *ctx, const char *path) > { > - snprintf(buffer, PATH_MAX, "%s/%s", ctx->fs_root, path); > - return buffer; > + return g_strdup_printf("%s/%s", ctx->fs_root, path); > } > > /* > -- Chen Gang Open, share and attitude like air, water and life which God blessed