From d3939f99fc294ab0f98a845b96271127eecb444f Mon Sep 17 00:00:00 2001 From: Xavi Hernandez Date: Mon, 1 Sep 2025 11:58:30 +0200 Subject: [PATCH] libcephfs_proxy: remove unnecessary protocol references in daemon With the new protocol structure definitions, it's not necessary to explicitly access each field inside its version substructure (v0, for example). Now all fields of the latest version are declared inside an anonymous substructure that can be accessed without a prefix. Fixes: https://tracker.ceph.com/issues/72800 Signed-off-by: Xavi Hernandez (cherry picked from commit b5df01a605d0adfa332e08665faea00bf7b0fbd0) --- src/libcephfs_proxy/libcephfsd.c | 480 +++++++++++++++---------------- 1 file changed, 231 insertions(+), 249 deletions(-) diff --git a/src/libcephfs_proxy/libcephfsd.c b/src/libcephfs_proxy/libcephfsd.c index 46b35d44e20f2..503019dc62c44 100644 --- a/src/libcephfs_proxy/libcephfsd.c +++ b/src/libcephfs_proxy/libcephfsd.c @@ -114,11 +114,11 @@ static int32_t libcephfsd_version(proxy_client_t *client, proxy_req_t *req, text = ceph_version(&major, &minor, &patch); TRACE("ceph_version(%d, %d, %d) -> %s", major, minor, patch, text); - ans.v0.major = major; - ans.v0.minor = minor; - ans.v0.patch = patch; + ans.major = major; + ans.minor = minor; + ans.patch = patch; - CEPH_STR_ADD(ans, v0.text, text); + CEPH_STR_ADD(ans, text, text); return CEPH_RET(client->sd, 0, ans); } @@ -134,16 +134,15 @@ static int32_t libcephfsd_userperm_new(proxy_client_t *client, proxy_req_t *req, return -EOPNOTSUPP; } - userperm = ceph_userperm_new(req->userperm_new.v0.uid, - req->userperm_new.v0.gid, - req->userperm_new.v0.groups, - (gid_t *)data); + userperm = ceph_userperm_new(req->userperm_new.uid, + req->userperm_new.gid, + req->userperm_new.groups, (gid_t *)data); TRACE("ceph_userperm_new(%u, %u, %u) -> %p", req->userperm_new.uid, req->userperm_new.gid, req->userperm_new.groups, userperm); err = -ENOMEM; if (userperm != NULL) { - ans.v0.userperm = ptr_checksum(&global_random, userperm); + ans.userperm = ptr_checksum(&global_random, userperm); err = 0; } @@ -162,7 +161,7 @@ static int32_t libcephfsd_userperm_destroy(proxy_client_t *client, return -EOPNOTSUPP; } - err = ptr_check(&global_random, req->userperm_destroy.v0.userperm, + err = ptr_check(&global_random, req->userperm_destroy.userperm, (void **)&perms); if (err >= 0) { @@ -181,13 +180,13 @@ static int32_t libcephfsd_create(proxy_client_t *client, proxy_req_t *req, const char *id; int32_t err; - id = CEPH_STR_GET(req->create, v0.id, data); + id = CEPH_STR_GET(req->create, id, data); err = proxy_mount_create(&mount, id); TRACE("ceph_create(%p, '%s') -> %d", mount, id, err); if (err >= 0) { - ans.v0.cmount = ptr_checksum(&client->random, mount); + ans.cmount = ptr_checksum(&client->random, mount); } return CEPH_COMPLETE(client, err, ans); @@ -200,8 +199,7 @@ static int32_t libcephfsd_release(proxy_client_t *client, proxy_req_t *req, proxy_mount_t *mount; int32_t err; - err = ptr_check(&client->random, req->release.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->release.cmount, (void **)&mount); if (err >= 0) { err = proxy_mount_release(mount); TRACE("ceph_release(%p) -> %d", mount, err); @@ -219,10 +217,10 @@ static int32_t libcephfsd_conf_read_file(proxy_client_t *client, const char *path; int32_t err; - err = ptr_check(&client->random, req->conf_read_file.v0.cmount, + err = ptr_check(&client->random, req->conf_read_file.cmount, (void **)&mount); if (err >= 0) { - path = CEPH_STR_GET(req->conf_read_file, v0.path, data); + path = CEPH_STR_GET(req->conf_read_file, path, data); err = proxy_mount_config(mount, path); TRACE("ceph_conf_read_file(%p, '%s') ->%d", mount, path, err); @@ -243,21 +241,20 @@ static int32_t libcephfsd_conf_get(proxy_client_t *client, proxy_req_t *req, buffer = client->buffer; size = client->buffer_size; - if (req->conf_get.v0.size < size) { - size = req->conf_get.v0.size; + if (req->conf_get.size < size) { + size = req->conf_get.size; } - err = ptr_check(&client->random, req->conf_get.v0.cmount, + err = ptr_check(&client->random, req->conf_get.cmount, (void **)&mount); if (err >= 0) { - option = CEPH_STR_GET(req->conf_get, v0.option, data); + option = CEPH_STR_GET(req->conf_get, option, data); err = proxy_mount_get(mount, option, buffer, size); TRACE("ceph_conf_get(%p, '%s', '%s') -> %d", mount, option, (char *)buffer, err); if (err >= 0) { - CEPH_DATA_ADD(ans, v0.value, buffer, - strlen(buffer) + 1); + CEPH_DATA_ADD(ans, value, buffer, strlen(buffer) + 1); } } @@ -272,12 +269,11 @@ static int32_t libcephfsd_conf_set(proxy_client_t *client, proxy_req_t *req, const char *option, *value; int32_t err; - err = ptr_check(&client->random, req->conf_set.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->conf_set.cmount, (void **)&mount); if (err >= 0) { - option = CEPH_STR_GET(req->conf_set, v0.option, data); - value = CEPH_STR_GET(req->conf_set, v0.value, - (const char *)(data) + req->conf_set.v0.option); + option = CEPH_STR_GET(req->conf_set, option, data); + value = CEPH_STR_GET(req->conf_set, value, + (const char *)(data) + req->conf_set.option); err = proxy_mount_set(mount, option, value); TRACE("ceph_conf_set(%p, '%s', '%s') -> %d", mount, option, @@ -294,7 +290,7 @@ static int32_t libcephfsd_init(proxy_client_t *client, proxy_req_t *req, proxy_mount_t *mount; int32_t err; - err = ptr_check(&client->random, req->init.v0.cmount, (void **)&mount); + err = ptr_check(&client->random, req->init.cmount, (void **)&mount); if (err >= 0) { err = proxy_mount_init(mount); TRACE("ceph_init(%p) -> %d", mount, err); @@ -312,10 +308,10 @@ static int32_t libcephfsd_select_filesystem(proxy_client_t *client, const char *fs; int32_t err; - err = ptr_check(&client->random, req->select_filesystem.v0.cmount, + err = ptr_check(&client->random, req->select_filesystem.cmount, (void **)&mount); if (err >= 0) { - fs = CEPH_STR_GET(req->select_filesystem, v0.fs, data); + fs = CEPH_STR_GET(req->select_filesystem, fs, data); err = proxy_mount_select(mount, fs); TRACE("ceph_select_filesystem(%p, '%s') -> %d", mount, fs, err); @@ -332,9 +328,9 @@ static int32_t libcephfsd_mount(proxy_client_t *client, proxy_req_t *req, const char *root; int32_t err; - err = ptr_check(&client->random, req->mount.v0.cmount, (void **)&mount); + err = ptr_check(&client->random, req->mount.cmount, (void **)&mount); if (err >= 0) { - root = CEPH_STR_GET(req->mount, v0.root, data); + root = CEPH_STR_GET(req->mount, root, data); err = proxy_mount_mount(mount, root); TRACE("ceph_mount(%p, '%s') -> %d", mount, root, err); @@ -350,8 +346,7 @@ static int32_t libcephfsd_unmount(proxy_client_t *client, proxy_req_t *req, proxy_mount_t *mount; int32_t err; - err = ptr_check(&client->random, req->unmount.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->unmount.cmount, (void **)&mount); if (err >= 0) { err = proxy_mount_unmount(mount); @@ -370,10 +365,10 @@ static int32_t libcephfsd_ll_statfs(proxy_client_t *client, proxy_req_t *req, struct Inode *inode; int32_t err; - err = ptr_check(&client->random, req->ll_statfs.v0.cmount, + err = ptr_check(&client->random, req->ll_statfs.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_statfs.v0.inode, + err = ptr_check(&client->random, req->ll_statfs.inode, (void **)&inode); } @@ -402,23 +397,23 @@ static int32_t libcephfsd_ll_lookup(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_lookup, v0.name, data); - data = (const char *)data + req->ll_lookup.v0.name; + name = CEPH_STR_GET(req->ll_lookup, name, data); + data = (const char *)data + req->ll_lookup.name; - err = ptr_check(&client->random, req->ll_lookup.v0.cmount, + err = ptr_check(&client->random, req->ll_lookup.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_lookup.v0.parent, + err = ptr_check(&client->random, req->ll_lookup.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_lookup.v0.userperm, - req->ll_lookup.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_lookup.userperm, + req->ll_lookup.ngroups, data, &perms, &embedded); } if (err >= 0) { - want = req->ll_lookup.v0.want; - flags = req->ll_lookup.v0.flags; + want = req->ll_lookup.want; + flags = req->ll_lookup.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -440,7 +435,7 @@ static int32_t libcephfsd_ll_lookup(proxy_client_t *client, proxy_req_t *req, mount, parent, name, out, want, flags, perms, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, out); + ans.inode = ptr_checksum(&client->random, out); } } @@ -461,17 +456,17 @@ static int32_t libcephfsd_ll_lookup_inode(proxy_client_t *client, struct inodeno_t ino; int32_t err; - err = ptr_check(&client->random, req->ll_lookup_inode.v0.cmount, + err = ptr_check(&client->random, req->ll_lookup_inode.cmount, (void **)&mount); if (err >= 0) { - ino = req->ll_lookup_inode.v0.ino; + ino = req->ll_lookup_inode.ino; err = ceph_ll_lookup_inode(proxy_cmount(mount), ino, &inode); TRACE("ceph_ll_lookup_inode(%p, %lu, %p) -> %d", mount, ino.val, inode, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -486,7 +481,7 @@ static int32_t libcephfsd_ll_lookup_root(proxy_client_t *client, proxy_mount_t *mount; int32_t err; - err = ptr_check(&client->random, req->ll_lookup_root.v0.cmount, + err = ptr_check(&client->random, req->ll_lookup_root.cmount, (void **)&mount); if (err >= 0) { /* The libcephfs view of the root of the mount could be @@ -498,8 +493,7 @@ static int32_t libcephfsd_ll_lookup_root(proxy_client_t *client, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, - mount->root); + ans.inode = ptr_checksum(&client->random, mount->root); } } @@ -514,10 +508,9 @@ static int32_t libcephfsd_ll_put(proxy_client_t *client, proxy_req_t *req, struct Inode *inode; int32_t err; - err = ptr_check(&client->random, req->ll_put.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_put.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_put.v0.inode, + err = ptr_check(&client->random, req->ll_put.inode, (void **)&inode); } @@ -544,19 +537,18 @@ static int32_t libcephfsd_ll_walk(proxy_client_t *client, proxy_req_t *req, embedded = false; - path = CEPH_STR_GET(req->ll_walk, v0.path, data); - data = (const char *)data + req->ll_walk.v0.path; + path = CEPH_STR_GET(req->ll_walk, path, data); + data = (const char *)data + req->ll_walk.path; - err = ptr_check(&client->random, req->ll_walk.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_walk.cmount, (void **)&mount); if (err >= 0) { - err = validate_perms(client, &req->ll_walk.v0.userperm, - req->ll_walk.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_walk.userperm, + req->ll_walk.ngroups, data, &perms, &embedded); } if (err >= 0) { - want = req->ll_walk.v0.want; - flags = req->ll_walk.v0.flags; + want = req->ll_walk.want; + flags = req->ll_walk.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -566,7 +558,7 @@ static int32_t libcephfsd_ll_walk(proxy_client_t *client, proxy_req_t *req, path, inode, want, flags, perms, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -588,9 +580,9 @@ static int32_t libcephfsd_chdir(proxy_client_t *client, proxy_req_t *req, char *realpath; int32_t err; - err = ptr_check(&client->random, req->chdir.v0.cmount, (void **)&mount); + err = ptr_check(&client->random, req->chdir.cmount, (void **)&mount); if (err >= 0) { - path = CEPH_STR_GET(req->chdir, v0.path, data); + path = CEPH_STR_GET(req->chdir, path, data); /* Since the libcephfs mount may be shared, we can't really * change the current directory to avoid interferences with @@ -625,14 +617,13 @@ static int32_t libcephfsd_getcwd(proxy_client_t *client, proxy_req_t *req, const char *path; int32_t err; - err = ptr_check(&client->random, req->getcwd.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->getcwd.cmount, (void **)&mount); if (err >= 0) { /* We just return the cached name from the last chdir(). */ path = mount->cwd_path; TRACE("ceph_getcwd(%p) -> '%s'", mount, path); - CEPH_STR_ADD(ans, v0.path, path); + CEPH_STR_ADD(ans, path, path); err = 0; } @@ -648,10 +639,10 @@ static int32_t libcephfsd_readdir(proxy_client_t *client, proxy_req_t *req, struct ceph_dir_result *dirp; int32_t err; - err = ptr_check(&client->random, req->readdir.v0.cmount, + err = ptr_check(&client->random, req->readdir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->readdir.v0.dir, + err = ptr_check(&client->random, req->readdir.dir, (void **)&dirp); } @@ -659,9 +650,9 @@ static int32_t libcephfsd_readdir(proxy_client_t *client, proxy_req_t *req, err = ceph_readdir_r(proxy_cmount(mount), dirp, &de); TRACE("ceph_readdir_r(%p, %p, %p) -> %d", mount, dirp, &de, err); - ans.v0.eod = true; + ans.eod = true; if (err > 0) { - ans.v0.eod = false; + ans.eod = false; CEPH_BUFF_ADD(ans, &de, offset_of(struct dirent, d_name) + strlen(de.d_name) + 1); @@ -679,10 +670,10 @@ static int32_t libcephfsd_rewinddir(proxy_client_t *client, proxy_req_t *req, struct ceph_dir_result *dirp; int32_t err; - err = ptr_check(&client->random, req->rewinddir.v0.cmount, + err = ptr_check(&client->random, req->rewinddir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->rewinddir.v0.dir, + err = ptr_check(&client->random, req->rewinddir.dir, (void **)&dirp); } @@ -707,19 +698,18 @@ static int32_t libcephfsd_ll_open(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_open.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_open.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_open.v0.inode, + err = ptr_check(&client->random, req->ll_open.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_open.v0.userperm, - req->ll_open.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_open.userperm, + req->ll_open.ngroups, data, &perms, &embedded); } if (err >= 0) { - flags = req->ll_open.v0.flags; + flags = req->ll_open.flags; err = ceph_ll_open(proxy_cmount(mount), inode, flags, &fh, perms); @@ -727,7 +717,7 @@ static int32_t libcephfsd_ll_open(proxy_client_t *client, proxy_req_t *req, flags, fh, perms, err); if (err >= 0) { - ans.v0.fh = ptr_checksum(&client->random, fh); + ans.fh = ptr_checksum(&client->random, fh); } } @@ -755,25 +745,25 @@ static int32_t libcephfsd_ll_create(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_create, v0.name, data); - data = (const char *)data + req->ll_create.v0.name; + name = CEPH_STR_GET(req->ll_create, name, data); + data = (const char *)data + req->ll_create.name; - err = ptr_check(&client->random, req->ll_create.v0.cmount, + err = ptr_check(&client->random, req->ll_create.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_create.v0.parent, + err = ptr_check(&client->random, req->ll_create.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_create.v0.userperm, - req->ll_create.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_create.userperm, + req->ll_create.ngroups, data, &perms, &embedded); } if (err >= 0) { - mode = req->ll_create.v0.mode; - oflags = req->ll_create.v0.oflags; - want = req->ll_create.v0.want; - flags = req->ll_create.v0.flags; + mode = req->ll_create.mode; + oflags = req->ll_create.oflags; + want = req->ll_create.want; + flags = req->ll_create.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -786,8 +776,8 @@ static int32_t libcephfsd_ll_create(proxy_client_t *client, proxy_req_t *req, perms, err); if (err >= 0) { - ans.v0.fh = ptr_checksum(&client->random, fh); - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.fh = ptr_checksum(&client->random, fh); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -815,25 +805,24 @@ static int32_t libcephfsd_ll_mknod(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_mknod, v0.name, data); - data = (const char *)data + req->ll_mknod.v0.name; + name = CEPH_STR_GET(req->ll_mknod, name, data); + data = (const char *)data + req->ll_mknod.name; - err = ptr_check(&client->random, req->ll_mknod.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_mknod.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_mknod.v0.parent, + err = ptr_check(&client->random, req->ll_mknod.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_mknod.v0.userperm, - req->ll_mknod.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_mknod.userperm, + req->ll_mknod.ngroups, data, &perms, &embedded); } if (err >= 0) { - mode = req->ll_mknod.v0.mode; - rdev = req->ll_mknod.v0.rdev; - want = req->ll_mknod.v0.want; - flags = req->ll_mknod.v0.flags; + mode = req->ll_mknod.mode; + rdev = req->ll_mknod.rdev; + want = req->ll_mknod.want; + flags = req->ll_mknod.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -845,7 +834,7 @@ static int32_t libcephfsd_ll_mknod(proxy_client_t *client, proxy_req_t *req, perms, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -864,10 +853,9 @@ static int32_t libcephfsd_ll_close(proxy_client_t *client, proxy_req_t *req, struct Fh *fh; int32_t err; - err = ptr_check(&client->random, req->ll_close.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_close.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_close.v0.fh, + err = ptr_check(&client->random, req->ll_close.fh, (void **)&fh); } @@ -892,24 +880,24 @@ static int32_t libcephfsd_ll_rename(proxy_client_t *client, proxy_req_t *req, embedded = false; - old_name = CEPH_STR_GET(req->ll_rename, v0.old_name, data); - data = (const char *)data + req->ll_rename.v0.old_name; - new_name = CEPH_STR_GET(req->ll_rename, v0.new_name, data); - data = (const char *)data + req->ll_rename.v0.new_name; + old_name = CEPH_STR_GET(req->ll_rename, old_name, data); + data = (const char *)data + req->ll_rename.old_name; + new_name = CEPH_STR_GET(req->ll_rename, new_name, data); + data = (const char *)data + req->ll_rename.new_name; - err = ptr_check(&client->random, req->ll_rename.v0.cmount, + err = ptr_check(&client->random, req->ll_rename.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_rename.v0.old_parent, + err = ptr_check(&client->random, req->ll_rename.old_parent, (void **)&old_parent); } if (err >= 0) { - err = ptr_check(&client->random, req->ll_rename.v0.new_parent, + err = ptr_check(&client->random, req->ll_rename.new_parent, (void **)&new_parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_rename.v0.userperm, - req->ll_rename.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_rename.userperm, + req->ll_rename.ngroups, data, &perms, &embedded); } if (err >= 0) { @@ -935,15 +923,14 @@ static int32_t libcephfsd_ll_lseek(proxy_client_t *client, proxy_req_t *req, off_t offset, pos; int32_t whence, err; - err = ptr_check(&client->random, req->ll_lseek.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_lseek.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_lseek.v0.fh, + err = ptr_check(&client->random, req->ll_lseek.fh, (void **)&fh); } if (err >= 0) { - offset = req->ll_lseek.v0.offset; - whence = req->ll_lseek.v0.whence; + offset = req->ll_lseek.offset; + whence = req->ll_lseek.whence; pos = ceph_ll_lseek(proxy_cmount(mount), fh, offset, whence); err = -errno; @@ -951,7 +938,7 @@ static int32_t libcephfsd_ll_lseek(proxy_client_t *client, proxy_req_t *req, offset, whence, pos, -err); if (pos >= 0) { - ans.v0.offset = pos; + ans.offset = pos; err = 0; } } @@ -973,15 +960,14 @@ static int32_t libcephfsd_ll_read(proxy_client_t *client, proxy_req_t *req, buffer = client->buffer; - err = ptr_check(&client->random, req->ll_read.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_read.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_read.v0.fh, + err = ptr_check(&client->random, req->ll_read.fh, (void **)&fh); } if (err >= 0) { - offset = req->ll_read.v0.offset; - len = req->ll_read.v0.len; + offset = req->ll_read.offset; + len = req->ll_read.len; size = client->buffer_size; if (len > size) { @@ -1021,15 +1007,14 @@ static int32_t libcephfsd_ll_write(proxy_client_t *client, proxy_req_t *req, int64_t offset; int32_t err; - err = ptr_check(&client->random, req->ll_write.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_write.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_write.v0.fh, + err = ptr_check(&client->random, req->ll_write.fh, (void **)&fh); } if (err >= 0) { - offset = req->ll_write.v0.offset; - len = req->ll_write.v0.len; + offset = req->ll_write.offset; + len = req->ll_write.len; err = ceph_ll_write(proxy_cmount(mount), fh, offset, len, data); TRACE("ceph_ll_write(%p, %p, %ld, %lu) -> %d", mount, fh, @@ -1052,22 +1037,21 @@ static int32_t libcephfsd_ll_link(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_link, v0.name, data); - data = (const char *)data + req->ll_link.v0.name; + name = CEPH_STR_GET(req->ll_link, name, data); + data = (const char *)data + req->ll_link.name; - err = ptr_check(&client->random, req->ll_link.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_link.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_link.v0.inode, + err = ptr_check(&client->random, req->ll_link.inode, (void **)&inode); } if (err >= 0) { - err = ptr_check(&client->random, req->ll_link.v0.parent, + err = ptr_check(&client->random, req->ll_link.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_link.v0.userperm, - req->ll_link.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_link.userperm, + req->ll_link.ngroups, data, &perms, &embedded); } if (err >= 0) { @@ -1097,18 +1081,18 @@ static int32_t libcephfsd_ll_unlink(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_unlink, v0.name, data); - data = (const char *)data + req->ll_unlink.v0.name; + name = CEPH_STR_GET(req->ll_unlink, name, data); + data = (const char *)data + req->ll_unlink.name; - err = ptr_check(&client->random, req->ll_unlink.v0.cmount, + err = ptr_check(&client->random, req->ll_unlink.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_unlink.v0.parent, + err = ptr_check(&client->random, req->ll_unlink.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_unlink.v0.userperm, - req->ll_unlink.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_unlink.userperm, + req->ll_unlink.ngroups, data, &perms, &embedded); } if (err >= 0) { @@ -1138,20 +1122,20 @@ static int32_t libcephfsd_ll_getattr(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_getattr.v0.cmount, + err = ptr_check(&client->random, req->ll_getattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_getattr.v0.inode, + err = ptr_check(&client->random, req->ll_getattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_getattr.v0.userperm, - req->ll_getattr.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_getattr.userperm, + req->ll_getattr.ngroups, data, &perms, &embedded); } if (err >= 0) { - want = req->ll_getattr.v0.want; - flags = req->ll_getattr.v0.flags; + want = req->ll_getattr.want; + flags = req->ll_getattr.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -1180,19 +1164,19 @@ static int32_t libcephfsd_ll_setattr(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_setattr.v0.cmount, + err = ptr_check(&client->random, req->ll_setattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_setattr.v0.inode, + err = ptr_check(&client->random, req->ll_setattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_setattr.v0.userperm, - req->ll_setattr.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_setattr.userperm, + req->ll_setattr.ngroups, data, &perms, &embedded); } if (err >= 0) { - mask = req->ll_setattr.v0.mask; + mask = req->ll_setattr.mask; err = ceph_ll_setattr(proxy_cmount(mount), inode, (void *)data, mask, perms); @@ -1217,16 +1201,16 @@ static int32_t libcephfsd_ll_fallocate(proxy_client_t *client, proxy_req_t *req, mode_t mode; int32_t err; - err = ptr_check(&client->random, req->ll_fallocate.v0.cmount, + err = ptr_check(&client->random, req->ll_fallocate.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_fallocate.v0.fh, + err = ptr_check(&client->random, req->ll_fallocate.fh, (void **)&fh); } if (err >= 0) { - mode = req->ll_fallocate.v0.mode; - offset = req->ll_fallocate.v0.offset; - len = req->ll_fallocate.v0.length; + mode = req->ll_fallocate.mode; + offset = req->ll_fallocate.offset; + len = req->ll_fallocate.length; err = ceph_ll_fallocate(proxy_cmount(mount), fh, mode, offset, len); @@ -1245,14 +1229,13 @@ static int32_t libcephfsd_ll_fsync(proxy_client_t *client, proxy_req_t *req, struct Fh *fh; int32_t dataonly, err; - err = ptr_check(&client->random, req->ll_fsync.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_fsync.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_fsync.v0.fh, + err = ptr_check(&client->random, req->ll_fsync.fh, (void **)&fh); } if (err >= 0) { - dataonly = req->ll_fsync.v0.dataonly; + dataonly = req->ll_fsync.dataonly; err = ceph_ll_fsync(proxy_cmount(mount), fh, dataonly); TRACE("ceph_ll_fsync(%p, %p, %d) -> %d", mount, fh, dataonly, @@ -1275,19 +1258,19 @@ static int32_t libcephfsd_ll_listxattr(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_listxattr.v0.cmount, + err = ptr_check(&client->random, req->ll_listxattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_listxattr.v0.inode, + err = ptr_check(&client->random, req->ll_listxattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_listxattr.v0.userperm, - req->ll_listxattr.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_listxattr.userperm, + req->ll_listxattr.ngroups, data, &perms, &embedded); } if (err >= 0) { - size = req->ll_listxattr.v0.size; + size = req->ll_listxattr.size; if (size > client->buffer_size) { size = client->buffer_size; } @@ -1297,7 +1280,7 @@ static int32_t libcephfsd_ll_listxattr(proxy_client_t *client, proxy_req_t *req, size, perms, err); if (err >= 0) { - ans.v0.size = size; + ans.size = size; CEPH_BUFF_ADD(ans, client->buffer, size); } } @@ -1323,22 +1306,22 @@ static int32_t libcephfsd_ll_getxattr(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_getxattr, v0.name, data); - data = (const char *)data + req->ll_getxattr.v0.name; + name = CEPH_STR_GET(req->ll_getxattr, name, data); + data = (const char *)data + req->ll_getxattr.name; - err = ptr_check(&client->random, req->ll_getxattr.v0.cmount, + err = ptr_check(&client->random, req->ll_getxattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_getxattr.v0.inode, + err = ptr_check(&client->random, req->ll_getxattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_getxattr.v0.userperm, - req->ll_getxattr.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_getxattr.userperm, + req->ll_getxattr.ngroups, data, &perms, &embedded); } if (err >= 0) { - size = req->ll_getxattr.v0.size; + size = req->ll_getxattr.size; if (size > client->buffer_size) { size = client->buffer_size; @@ -1374,25 +1357,25 @@ static int32_t libcephfsd_ll_setxattr(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_setxattr, v0.name, data); - data = (const char *)data + req->ll_setxattr.v0.name; + name = CEPH_STR_GET(req->ll_setxattr, name, data); + data = (const char *)data + req->ll_setxattr.name; value = data; - size = req->ll_setxattr.v0.size; + size = req->ll_setxattr.size; data = (const char *)data + size; - err = ptr_check(&client->random, req->ll_setxattr.v0.cmount, + err = ptr_check(&client->random, req->ll_setxattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_setxattr.v0.inode, + err = ptr_check(&client->random, req->ll_setxattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_setxattr.v0.userperm, - req->ll_setxattr.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_setxattr.userperm, + req->ll_setxattr.ngroups, data, &perms, &embedded); } if (err >= 0) { - flags = req->ll_setxattr.v0.flags; + flags = req->ll_setxattr.flags; err = ceph_ll_setxattr(proxy_cmount(mount), inode, name, value, size, flags, perms); @@ -1421,18 +1404,18 @@ static int32_t libcephfsd_ll_removexattr(proxy_client_t *client, embedded = false; - name = CEPH_STR_GET(req->ll_removexattr, v0.name, data); - data = (const char *)data + req->ll_removexattr.v0.name; + name = CEPH_STR_GET(req->ll_removexattr, name, data); + data = (const char *)data + req->ll_removexattr.name; - err = ptr_check(&client->random, req->ll_removexattr.v0.cmount, + err = ptr_check(&client->random, req->ll_removexattr.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_removexattr.v0.inode, + err = ptr_check(&client->random, req->ll_removexattr.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_removexattr.v0.userperm, - req->ll_removexattr.v1.ngroups, data, + err = validate_perms(client, &req->ll_removexattr.userperm, + req->ll_removexattr.ngroups, data, &perms, &embedded); } if (err >= 0) { @@ -1462,19 +1445,19 @@ static int32_t libcephfsd_ll_readlink(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_readlink.v0.cmount, + err = ptr_check(&client->random, req->ll_readlink.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_readlink.v0.inode, + err = ptr_check(&client->random, req->ll_readlink.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_readlink.v0.userperm, - req->ll_readlink.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_readlink.userperm, + req->ll_readlink.ngroups, data, &perms, &embedded); } if (err >= 0) { - size = req->ll_readlink.v0.size; + size = req->ll_readlink.size; if (size > client->buffer_size) { size = client->buffer_size; @@ -1507,25 +1490,25 @@ static int32_t libcephfsd_ll_symlink(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_symlink, v0.name, data); - data = (const char *)data + req->ll_symlink.v0.name; - value = CEPH_STR_GET(req->ll_symlink, v0.target, data); - data = (const char *)data + req->ll_symlink.v0.target; + name = CEPH_STR_GET(req->ll_symlink, name, data); + data = (const char *)data + req->ll_symlink.name; + value = CEPH_STR_GET(req->ll_symlink, target, data); + data = (const char *)data + req->ll_symlink.target; - err = ptr_check(&client->random, req->ll_symlink.v0.cmount, + err = ptr_check(&client->random, req->ll_symlink.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_symlink.v0.parent, + err = ptr_check(&client->random, req->ll_symlink.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_symlink.v0.userperm, - req->ll_symlink.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_symlink.userperm, + req->ll_symlink.ngroups, data, &perms, &embedded); } if (err >= 0) { - want = req->ll_symlink.v0.want; - flags = req->ll_symlink.v0.flags; + want = req->ll_symlink.want; + flags = req->ll_symlink.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -1537,7 +1520,7 @@ static int32_t libcephfsd_ll_symlink(proxy_client_t *client, proxy_req_t *req, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -1561,15 +1544,15 @@ static int32_t libcephfsd_ll_opendir(proxy_client_t *client, proxy_req_t *req, embedded = false; - err = ptr_check(&client->random, req->ll_opendir.v0.cmount, + err = ptr_check(&client->random, req->ll_opendir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_opendir.v0.inode, + err = ptr_check(&client->random, req->ll_opendir.inode, (void **)&inode); } if (err >= 0) { - err = validate_perms(client, &req->ll_opendir.v0.userperm, - req->ll_opendir.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_opendir.userperm, + req->ll_opendir.ngroups, data, &perms, &embedded); } @@ -1579,7 +1562,7 @@ static int32_t libcephfsd_ll_opendir(proxy_client_t *client, proxy_req_t *req, dirp, perms, err); if (err >= 0) { - ans.v0.dir = ptr_checksum(&client->random, dirp); + ans.dir = ptr_checksum(&client->random, dirp); } } @@ -1606,23 +1589,23 @@ static int32_t libcephfsd_ll_mkdir(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_mkdir, v0.name, data); - data = (const char *)data + req->ll_mkdir.v0.name; + name = CEPH_STR_GET(req->ll_mkdir, name, data); + data = (const char *)data + req->ll_mkdir.name; - err = ptr_check(&client->random, req->ll_mkdir.v0.cmount, (void **)&mount); + err = ptr_check(&client->random, req->ll_mkdir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_mkdir.v0.parent, + err = ptr_check(&client->random, req->ll_mkdir.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_mkdir.v0.userperm, - req->ll_mkdir.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_mkdir.userperm, + req->ll_mkdir.ngroups, data, &perms, &embedded); } if (err >= 0) { - mode = req->ll_mkdir.v0.mode; - want = req->ll_mkdir.v0.want; - flags = req->ll_mkdir.v0.flags; + mode = req->ll_mkdir.mode; + want = req->ll_mkdir.want; + flags = req->ll_mkdir.flags; CEPH_BUFF_ADD(ans, &stx, sizeof(stx)); @@ -1633,7 +1616,7 @@ static int32_t libcephfsd_ll_mkdir(proxy_client_t *client, proxy_req_t *req, err); if (err >= 0) { - ans.v0.inode = ptr_checksum(&client->random, inode); + ans.inode = ptr_checksum(&client->random, inode); } } @@ -1657,18 +1640,17 @@ static int32_t libcephfsd_ll_rmdir(proxy_client_t *client, proxy_req_t *req, embedded = false; - name = CEPH_STR_GET(req->ll_rmdir, v0.name, data); - data = (const char *)data + req->ll_rmdir.v0.name; + name = CEPH_STR_GET(req->ll_rmdir, name, data); + data = (const char *)data + req->ll_rmdir.name; - err = ptr_check(&client->random, req->ll_rmdir.v0.cmount, - (void **)&mount); + err = ptr_check(&client->random, req->ll_rmdir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_rmdir.v0.parent, + err = ptr_check(&client->random, req->ll_rmdir.parent, (void **)&parent); } if (err >= 0) { - err = validate_perms(client, &req->ll_rmdir.v0.userperm, - req->ll_rmdir.v1.ngroups, data, &perms, + err = validate_perms(client, &req->ll_rmdir.userperm, + req->ll_rmdir.ngroups, data, &perms, &embedded); } if (err >= 0) { @@ -1693,10 +1675,10 @@ static int32_t libcephfsd_ll_releasedir(proxy_client_t *client, struct ceph_dir_result *dirp; int32_t err; - err = ptr_check(&client->random, req->ll_releasedir.v0.cmount, + err = ptr_check(&client->random, req->ll_releasedir.cmount, (void **)&mount); if (err >= 0) { - err = ptr_check(&client->random, req->ll_releasedir.v0.dir, + err = ptr_check(&client->random, req->ll_releasedir.dir, (void **)&dirp); } @@ -1720,13 +1702,13 @@ static int32_t libcephfsd_mount_perms(proxy_client_t *client, proxy_req_t *req, return -EOPNOTSUPP; } - err = ptr_check(&client->random, req->mount_perms.v0.cmount, + err = ptr_check(&client->random, req->mount_perms.cmount, (void **)&mount); if (err >= 0) { perms = ceph_mount_perms(proxy_cmount(mount)); TRACE("ceph_mount_perms(%p) -> %p", mount, perms); - ans.v0.userperm = ptr_checksum(&global_random, perms); + ans.userperm = ptr_checksum(&global_random, perms); } return CEPH_COMPLETE(client, err, ans); @@ -1742,11 +1724,11 @@ static void libcephfsd_ll_nonblocking_rw_cbk(struct ceph_ll_io_info *cb_info) async_io = container_of(cb_info, proxy_async_io_t, io_info); async = async_io->async; - cbk.v0.info = (uintptr_t)cb_info->priv; - cbk.v0.res = cb_info->result; + cbk.info = (uintptr_t)cb_info->priv; + cbk.res = cb_info->result; - if ((cbk.v0.res >= 0) && !cb_info->write) { - CEPH_BUFF_ADD(cbk, cb_info->iov->iov_base, cbk.v0.res); + if ((cbk.res >= 0) && !cb_info->write) { + CEPH_BUFF_ADD(cbk, cb_info->iov->iov_base, cbk.res); } err = CEPH_CALL_CBK(async->fd, LIBCEPHFSD_CBK_LL_NONBLOCKING_RW, cbk); @@ -1778,7 +1760,7 @@ static int32_t libcephfsd_ll_nonblocking_rw(proxy_client_t *client, return -EOPNOTSUPP; } - err = ptr_check(&client->random, req->ll_nonblocking_rw.v0.cmount, + err = ptr_check(&client->random, req->ll_nonblocking_rw.cmount, (void **)&mount); if (err < 0) { goto done; @@ -1793,15 +1775,15 @@ static int32_t libcephfsd_ll_nonblocking_rw(proxy_client_t *client, memset(io_info, 0, sizeof(struct ceph_ll_io_info)); io_info->callback = libcephfsd_ll_nonblocking_rw_cbk; - io_info->priv = (void *)(uintptr_t)req->ll_nonblocking_rw.v0.info; + io_info->priv = (void *)(uintptr_t)req->ll_nonblocking_rw.info; io_info->iov = &async_io->iov; io_info->iovcnt = 1; - io_info->off = req->ll_nonblocking_rw.v0.off; - io_info->write = req->ll_nonblocking_rw.v0.write; - io_info->fsync = req->ll_nonblocking_rw.v0.fsync; - io_info->syncdataonly = req->ll_nonblocking_rw.v0.syncdataonly; + io_info->off = req->ll_nonblocking_rw.off; + io_info->write = req->ll_nonblocking_rw.write; + io_info->fsync = req->ll_nonblocking_rw.fsync; + io_info->syncdataonly = req->ll_nonblocking_rw.syncdataonly; - err = ptr_check(&client->random, req->ll_nonblocking_rw.v0.fh, + err = ptr_check(&client->random, req->ll_nonblocking_rw.fh, (void **)&io_info->fh); if (err < 0) { goto done; @@ -1811,7 +1793,7 @@ static int32_t libcephfsd_ll_nonblocking_rw(proxy_client_t *client, async_io->iov.iov_len = data_size; async_io->iov.iov_base = (void *)data; } else { - async_io->iov.iov_len = req->ll_nonblocking_rw.v0.size; + async_io->iov.iov_len = req->ll_nonblocking_rw.size; async_io->iov.iov_base = proxy_malloc(async_io->iov.iov_len); if (async_io->iov.iov_base == NULL) { proxy_free(async_io); @@ -1825,7 +1807,7 @@ static int32_t libcephfsd_ll_nonblocking_rw(proxy_client_t *client, res = ceph_ll_nonblocking_readv_writev(proxy_cmount(mount), io_info); TRACE("ceph_ll_nonblocking_readv_writev(%p) -> %ld", mount, res); - ans.v0.res = res; + ans.res = res; if (res < 0) { if (!io_info->write) { proxy_free(async_io->iov.iov_base); -- 2.39.5