OpenE2K
/
qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

virtiofsd: passthrough_ll: add ino_map to hide lo_inode pointers 

Do not expose lo_inode pointers to clients.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Masayoshi Mizuma <m.mizuma@jp.fujitsu.com>
Signed-off-by: Dr. David Alan Gilbert <dgilbert@redhat.com>
This commit is contained in:
Stefan Hajnoczi 2019-01-31 12:57:34 +08:00 committed by Dr. David Alan Gilbert
parent 25c135727b
commit 92fb57b83c
1 changed files with 114 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

144
tools/virtiofsd/passthrough_ll.c
View File

@ -57,8 +57,8 @@
#include "passthrough_helpers.h" #include "passthrough_helpers.h"
/* /*
* We are re-using pointers to our `struct lo_inode` and `struct * We are re-using pointers to our `struct lo_inode`
* lo_dirp` elements as inodes. This means that we must be able to * elements as inodes. This means that we must be able to
* store uintptr_t values in a fuse_ino_t variable. The following * store uintptr_t values in a fuse_ino_t variable. The following
* incantation checks this condition at compile time. * incantation checks this condition at compile time.
*/ */
@ -76,7 +76,7 @@ struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct {
struct lo_map_elem { struct lo_map_elem {
union { union {
/* Element values will go here... */ struct lo_inode *inode;
ssize_t freelist; ssize_t freelist;
}; };
bool in_use; bool in_use;
@ -97,6 +97,7 @@ struct lo_inode {
ino_t ino; ino_t ino;
dev_t dev; dev_t dev;
uint64_t refcount; /* protected by lo->mutex */ uint64_t refcount; /* protected by lo->mutex */
fuse_ino_t fuse_ino;
}; };
struct lo_cred { struct lo_cred {
@ -121,6 +122,7 @@ struct lo_data {
int cache; int cache;
int timeout_set; int timeout_set;
struct lo_inode root; /* protected by lo->mutex */ struct lo_inode root; /* protected by lo->mutex */
struct lo_map ino_map; /* protected by lo->mutex */
}; };
static const struct fuse_opt lo_opts[] = { static const struct fuse_opt lo_opts[] = {
@ -145,14 +147,14 @@ static struct lo_data *lo_data(fuse_req_t req)
return (struct lo_data *)fuse_req_userdata(req); return (struct lo_data *)fuse_req_userdata(req);
} }
__attribute__((unused)) static void lo_map_init(struct lo_map *map) static void lo_map_init(struct lo_map *map)
{ {
map->elems = NULL; map->elems = NULL;
map->nelems = 0; map->nelems = 0;
map->freelist = -1; map->freelist = -1;
} }
__attribute__((unused)) static void lo_map_destroy(struct lo_map *map) static void lo_map_destroy(struct lo_map *map)
{ {
free(map->elems); free(map->elems);
} }
@ -183,8 +185,7 @@ static int lo_map_grow(struct lo_map *map, size_t new_nelems)
return 1; return 1;
} }
__attribute__((unused)) static struct lo_map_elem * static struct lo_map_elem *lo_map_alloc_elem(struct lo_map *map)
lo_map_alloc_elem(struct lo_map *map)
{ {
struct lo_map_elem *elem; struct lo_map_elem *elem;
@ -200,8 +201,7 @@ lo_map_alloc_elem(struct lo_map *map)
return elem; return elem;
} }
__attribute__((unused)) static struct lo_map_elem * static struct lo_map_elem *lo_map_reserve(struct lo_map *map, size_t key)
lo_map_reserve(struct lo_map *map, size_t key)
{ {
ssize_t *prev; ssize_t *prev;
@ -222,8 +222,7 @@ lo_map_reserve(struct lo_map *map, size_t key)
return NULL; return NULL;
} }
__attribute__((unused)) static struct lo_map_elem * static struct lo_map_elem *lo_map_get(struct lo_map *map, size_t key)
lo_map_get(struct lo_map *map, size_t key)
{ {
if (key >= map->nelems) { if (key >= map->nelems) {
return NULL; return NULL;
@ -234,8 +233,7 @@ lo_map_get(struct lo_map *map, size_t key)
return &map->elems[key]; return &map->elems[key];
} }
__attribute__((unused)) static void lo_map_remove(struct lo_map *map, static void lo_map_remove(struct lo_map *map, size_t key)
size_t key)
{ {
struct lo_map_elem *elem; struct lo_map_elem *elem;
@ -254,18 +252,40 @@ __attribute__((unused)) static void lo_map_remove(struct lo_map *map,
map->freelist = key; map->freelist = key;
} }
/* Assumes lo->mutex is held */
static ssize_t lo_add_inode_mapping(fuse_req_t req, struct lo_inode *inode)
{
struct lo_map_elem *elem;
elem = lo_map_alloc_elem(&lo_data(req)->ino_map);
if (!elem) {
return -1;
}
elem->inode = inode;
return elem - lo_data(req)->ino_map.elems;
}
static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino) static struct lo_inode *lo_inode(fuse_req_t req, fuse_ino_t ino)
{ {
if (ino == FUSE_ROOT_ID) { struct lo_data *lo = lo_data(req);
return &lo_data(req)->root; struct lo_map_elem *elem;
} else {
return (struct lo_inode *)(uintptr_t)ino; pthread_mutex_lock(&lo->mutex);
elem = lo_map_get(&lo->ino_map, ino);
pthread_mutex_unlock(&lo->mutex);
if (!elem) {
return NULL;
} }
return elem->inode;
} }
static int lo_fd(fuse_req_t req, fuse_ino_t ino) static int lo_fd(fuse_req_t req, fuse_ino_t ino)
{ {
return lo_inode(req, ino)->fd; struct lo_inode *inode = lo_inode(req, ino);
return inode ? inode->fd : -1;
} }
static bool lo_debug(fuse_req_t req) static bool lo_debug(fuse_req_t req)
@ -337,10 +357,18 @@ static void lo_setattr(fuse_req_t req, fuse_ino_t ino, struct stat *attr,
{ {
int saverr; int saverr;
char procname[64]; char procname[64];
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
int ifd = inode->fd; int ifd;
int res; int res;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
ifd = inode->fd;
if (valid & FUSE_SET_ATTR_MODE) { if (valid & FUSE_SET_ATTR_MODE) {
if (fi) { if (fi) {
res = fchmod(fi->fh, attr->st_mode); res = fchmod(fi->fh, attr->st_mode);
@ -470,6 +498,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
inode->dev = e->attr.st_dev; inode->dev = e->attr.st_dev;
pthread_mutex_lock(&lo->mutex); pthread_mutex_lock(&lo->mutex);
inode->fuse_ino = lo_add_inode_mapping(req, inode);
prev = &lo->root; prev = &lo->root;
next = prev->next; next = prev->next;
next->prev = inode; next->prev = inode;
@ -478,7 +507,7 @@ static int lo_do_lookup(fuse_req_t req, fuse_ino_t parent, const char *name,
prev->next = inode; prev->next = inode;
pthread_mutex_unlock(&lo->mutex); pthread_mutex_unlock(&lo->mutex);
} }
e->ino = (uintptr_t)inode; e->ino = inode->fuse_ino;
if (lo_debug(req)) { if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
@ -582,10 +611,16 @@ static void lo_mknod_symlink(fuse_req_t req, fuse_ino_t parent,
{ {
int res; int res;
int saverr; int saverr;
struct lo_inode *dir = lo_inode(req, parent); struct lo_inode *dir;
struct fuse_entry_param e; struct fuse_entry_param e;
struct lo_cred old = {}; struct lo_cred old = {};
dir = lo_inode(req, parent);
if (!dir) {
fuse_reply_err(req, EBADF);
return;
}
saverr = ENOMEM; saverr = ENOMEM;
saverr = lo_change_cred(req, &old); saverr = lo_change_cred(req, &old);
@ -663,10 +698,16 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
{ {
int res; int res;
struct lo_data *lo = lo_data(req); struct lo_data *lo = lo_data(req);
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
struct fuse_entry_param e; struct fuse_entry_param e;
int saverr; int saverr;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
memset(&e, 0, sizeof(struct fuse_entry_param)); memset(&e, 0, sizeof(struct fuse_entry_param));
e.attr_timeout = lo->timeout; e.attr_timeout = lo->timeout;
e.entry_timeout = lo->timeout; e.entry_timeout = lo->timeout;
@ -684,7 +725,7 @@ static void lo_link(fuse_req_t req, fuse_ino_t ino, fuse_ino_t parent,
pthread_mutex_lock(&lo->mutex); pthread_mutex_lock(&lo->mutex);
inode->refcount++; inode->refcount++;
pthread_mutex_unlock(&lo->mutex); pthread_mutex_unlock(&lo->mutex);
e.ino = (uintptr_t)inode; e.ino = inode->fuse_ino;
if (lo_debug(req)) { if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n", fuse_log(FUSE_LOG_DEBUG, " %lli/%s -> %lli\n",
@ -750,10 +791,10 @@ static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
next->prev = prev; next->prev = prev;
prev->next = next; prev->next = next;
lo_map_remove(&lo->ino_map, inode->fuse_ino);
pthread_mutex_unlock(&lo->mutex); pthread_mutex_unlock(&lo->mutex);
close(inode->fd); close(inode->fd);
free(inode); free(inode);
} else { } else {
pthread_mutex_unlock(&lo->mutex); pthread_mutex_unlock(&lo->mutex);
} }
@ -762,7 +803,12 @@ static void unref_inode(struct lo_data *lo, struct lo_inode *inode, uint64_t n)
static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup) static void lo_forget_one(fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{ {
struct lo_data *lo = lo_data(req); struct lo_data *lo = lo_data(req);
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
inode = lo_inode(req, ino);
if (!inode) {
return;
}
if (lo_debug(req)) { if (lo_debug(req)) {
fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n", fuse_log(FUSE_LOG_DEBUG, " forget %lli %lli -%lli\n",
@ -1244,10 +1290,16 @@ static void lo_getxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
{ {
char *value = NULL; char *value = NULL;
char procname[64]; char procname[64];
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
ssize_t ret; ssize_t ret;
int saverr; int saverr;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
saverr = ENOSYS; saverr = ENOSYS;
if (!lo_data(req)->xattr) { if (!lo_data(req)->xattr) {
goto out; goto out;
@ -1306,10 +1358,16 @@ static void lo_listxattr(fuse_req_t req, fuse_ino_t ino, size_t size)
{ {
char *value = NULL; char *value = NULL;
char procname[64]; char procname[64];
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
ssize_t ret; ssize_t ret;
int saverr; int saverr;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
saverr = ENOSYS; saverr = ENOSYS;
if (!lo_data(req)->xattr) { if (!lo_data(req)->xattr) {
goto out; goto out;
@ -1367,10 +1425,16 @@ static void lo_setxattr(fuse_req_t req, fuse_ino_t ino, const char *name,
const char *value, size_t size, int flags) const char *value, size_t size, int flags)
{ {
char procname[64]; char procname[64];
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
ssize_t ret; ssize_t ret;
int saverr; int saverr;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
saverr = ENOSYS; saverr = ENOSYS;
if (!lo_data(req)->xattr) { if (!lo_data(req)->xattr) {
goto out; goto out;
@ -1400,10 +1464,16 @@ out:
static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name) static void lo_removexattr(fuse_req_t req, fuse_ino_t ino, const char *name)
{ {
char procname[64]; char procname[64];
struct lo_inode *inode = lo_inode(req, ino); struct lo_inode *inode;
ssize_t ret; ssize_t ret;
int saverr; int saverr;
inode = lo_inode(req, ino);
if (!inode) {
fuse_reply_err(req, EBADF);
return;
}
saverr = ENOSYS; saverr = ENOSYS;
if (!lo_data(req)->xattr) { if (!lo_data(req)->xattr) {
goto out; goto out;
@ -1522,6 +1592,7 @@ int main(int argc, char *argv[])
struct fuse_session *se; struct fuse_session *se;
struct fuse_cmdline_opts opts; struct fuse_cmdline_opts opts;
struct lo_data lo = { .debug = 0, .writeback = 0 }; struct lo_data lo = { .debug = 0, .writeback = 0 };
struct lo_map_elem *root_elem;
int ret = -1; int ret = -1;
/* Don't mask creation mode, kernel already did that */ /* Don't mask creation mode, kernel already did that */
@ -1530,8 +1601,19 @@ int main(int argc, char *argv[])
pthread_mutex_init(&lo.mutex, NULL); pthread_mutex_init(&lo.mutex, NULL);
lo.root.next = lo.root.prev = &lo.root; lo.root.next = lo.root.prev = &lo.root;
lo.root.fd = -1; lo.root.fd = -1;
lo.root.fuse_ino = FUSE_ROOT_ID;
lo.cache = CACHE_NORMAL; lo.cache = CACHE_NORMAL;
/*
* Set up the ino map like this:
* [0] Reserved (will not be used)
* [1] Root inode
*/
lo_map_init(&lo.ino_map);
lo_map_reserve(&lo.ino_map, 0)->in_use = false;
root_elem = lo_map_reserve(&lo.ino_map, lo.root.fuse_ino);
root_elem->inode = &lo.root;
if (fuse_parse_cmdline(&args, &opts) != 0) { if (fuse_parse_cmdline(&args, &opts) != 0) {
return 1; return 1;
} }
@ -1628,6 +1710,8 @@ err_out2:
err_out1: err_out1:
fuse_opt_free_args(&args); fuse_opt_free_args(&args);
lo_map_destroy(&lo.ino_map);
if (lo.root.fd >= 0) { if (lo.root.fd >= 0) {
close(lo.root.fd); close(lo.root.fd);
} }