TheCloud/fuse-overlayfs
1
0
Fork 0
mirror of https://github.com/containers/fuse-overlayfs.git synced 2025-08-03 18:05:58 -04:00
Code Issues Packages Projects Releases Wiki Activity
fuse-overlayfs/main.c
Giuseppe Scrivano 26f0f1a6a2
containerfs: initial implementation 
A FUSE implementation of overlay.  Not as stable and mature as the
kernel FS.

Signed-off-by: Giuseppe Scrivano <gscrivan@redhat.com>
2018-06-17 16:34:29 +02:00

2857 lines
60 KiB
C
Raw Blame History

/* containers: Overlay Filesystem in Userspace
Copyright (C) 2018 Giuseppe Scrivano <giuseppe@scrivano.org>
Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#define _GNU_SOURCE
#define FUSE_USE_VERSION 31
#define _FILE_OFFSET_BITS 64
#include <config.h>
#include <fuse_lowlevel.h>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <stdbool.h>
#include <string.h>
#include <limits.h>
#include <dirent.h>
#include <assert.h>
#include <errno.h>
#include <err.h>
#include <error.h>
#include <inttypes.h>
#include <fcntl.h>
#include <hash.h>
#include <sys/statvfs.h>
#include <sys/file.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/syscall.h>
#include <fts.h>
#include <sys/xattr.h>
#ifndef RENAME_EXCHANGE
# define RENAME_EXCHANGE (1 << 1)
# define RENAME_NOREPLACE (1 << 2)
#endif
#define ATTR_TIMEOUT 1000000000.0
#define ENTRY_TIMEOUT 1000000000.0
#define NODE_TO_INODE(x) ((fuse_ino_t) x)
#if defined(__GNUC__) && (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 6) && !defined __cplusplus
_Static_assert (sizeof (fuse_ino_t) >= sizeof (uintptr_t),
"fuse_ino_t too small to hold uintptr_t values!");
#else
struct _uintptr_to_must_hold_fuse_ino_t_dummy_struct
{
unsigned _uintptr_to_must_hold_fuse_ino_t:
((sizeof (fuse_ino_t) >= sizeof (uintptr_t)) ? 1 : -1);
};
#endif
static size_t
str_hasher (const void *p, size_t s)
{
const char *str = (const char *) p;
return hash_string (str, s);
}
static bool
str_compare (const void *n1, const void *n2)
{
const char *s1 = (const char *) n1;
const char *s2 = (const char *) n2;
return strcmp (s1, s2) == 0 ? true : false;
}
struct lo_dir
{
struct lo_dir *next;
struct lo_dir *prev;
char *path;
int fd;
};
struct lo_node
{
struct lo_node *parent;
struct lo_node *lowerdir;
Hash_table *children;
char *path;
char *name;
int lookups;
unsigned int dirty : 1;
unsigned int low : 1;
unsigned int do_unlink : 1;
unsigned int do_rmdir : 1;
unsigned int hidden : 1;
unsigned int not_exists : 1;
};
struct lo_data
{
struct fuse_session *se;
int debug;
int uid;
int gid;
char *lowerdir;
char *context;
char *upperdir;
char *workdir;
struct lo_node *root_lower;
struct lo_node *root_upper;
};
static const struct fuse_opt lo_opts[] = {
{"context=%s",
offsetof (struct lo_data, context), 0},
{"lowerdir=%s",
offsetof (struct lo_data, lowerdir), 0},
{"upperdir=%s",
offsetof (struct lo_data, upperdir), 0},
{"workdir=%s",
offsetof (struct lo_data, workdir), 0},
{"uid=%i",
offsetof (struct lo_data, uid), -1},
{"gid=%i",
offsetof (struct lo_data, gid), -1},
FUSE_OPT_END
};
static struct lo_data *
lo_data (fuse_req_t req)
{
return (struct lo_data *) fuse_req_userdata (req);
}
/* Useful in a gdb session. */
static void
dump_directory (struct lo_node *node)
{
struct lo_node *it;
if (node->children == NULL)
return;
for (it = hash_get_first (node->children); it; it = hash_get_next (node->children, it))
printf ("ENTRY: %s (%s)\n", it->name, it->path);
}
static bool
lo_debug (fuse_req_t req)
{
return lo_data (req)->debug != 0;
}
static void
lo_init (void *userdata, struct fuse_conn_info *conn)
{
conn->want |= FUSE_CAP_DONT_MASK | FUSE_CAP_SPLICE_READ | FUSE_CAP_SPLICE_MOVE;
conn->want &= ~FUSE_CAP_PARALLEL_DIROPS;
}
/* FIXME: support proper ID ranges. */
static uid_t
get_uid (struct lo_data *lo, uid_t id)
{
if (lo->uid == id)
return geteuid ();
return id;
}
static uid_t
get_gid (struct lo_data *lo, gid_t id)
{
if (lo->gid == id)
return getegid ();
return id;
}
static inline bool
node_dirp (struct lo_node *n)
{
return n->children != NULL;
}
static char *
get_node_path (struct lo_node *node)
{
if (node->not_exists)
return node->lowerdir->path;
return node->path;
}
static void
hide_node (struct lo_data *lo, struct lo_node *node)
{
char *src = node->path;
node->hidden = 1;
node->parent = NULL;
node->path = tempnam (lo->workdir, NULL);
if (node->path == NULL)
{
free (src);
return;
}
if (rename (src, node->path) < 0)
{
free (src);
return;
}
node->do_unlink = 1;
}
static int
rpl_stat (fuse_req_t req, struct lo_node *node, struct stat *st)
{
int ret;
struct lo_data *data = lo_data (req);
if (! node->not_exists)
ret = lstat (node->path, st);
else
ret = lstat (node->lowerdir->path, st);
if (ret < 0)
return ret;
if (data->uid >= 0)
st->st_uid = data->uid;
if (data->gid >= 0)
st->st_gid = data->gid;
st->st_ino = NODE_TO_INODE (node);
if (ret == 0 && node_dirp (node))
{
struct lo_node *it;
st->st_nlink = 2;
for (it = hash_get_first (node->children); it; it = hash_get_next (node->children, it))
{
if (node_dirp (it))
st->st_nlink++;
}
if (node->lowerdir)
{
for (it = hash_get_first (node->lowerdir->children); it; it = hash_get_next (node->lowerdir->children, it))
{
if (node_dirp (it) && it->lowerdir == NULL)
st->st_nlink++;
}
}
}
return ret;
}
static void
node_mark_all_free (void *p)
{
struct lo_node *it, *n = (struct lo_node *) p;
n->lookups = 0;
if (n->children)
{
for (it = hash_get_first (n->children); it; it = hash_get_next (n->children, it))
node_mark_all_free (it);
}
}
static void
node_free (void *p)
{
struct lo_node *n = (struct lo_node *) p;
if (n->parent)
{
if (hash_lookup (n->parent->children, n) == n)
hash_delete (n->parent->children, n);
n->parent->dirty = 1;
n->parent = NULL;
}
if (n->lookups > 0)
return;
if (n->children)
{
struct lo_node *it;
for (it = hash_get_first (n->children); it; it = hash_get_next (n->children, it))
it->parent = NULL;
hash_free (n->children);
n->children = NULL;
}
if (! n->not_exists)
{
if (n->do_unlink)
unlink (n->path);
if (n->do_rmdir)
rmdir (n->path);
}
free (n->name);
n->name = NULL;
free (n->path);
n->path = NULL;
free (n);
}
static void
do_forget (fuse_ino_t ino, uint64_t nlookup)
{
struct lo_node *n;
if (ino == FUSE_ROOT_ID)
return;
n = (struct lo_node *) ino;
if (n->low)
return;
n->lookups -= nlookup;
if (n->lookups <= 0)
node_free (n);
}
static void
lo_forget (fuse_req_t req, fuse_ino_t ino, uint64_t nlookup)
{
if (lo_debug (req))
fprintf (stderr, "lo_forget(ino=%" PRIu64 ", nlookup=%lu)\n",
ino, nlookup);
do_forget (ino, nlookup);
fuse_reply_none (req);
}
static size_t
node_hasher (const void *p, size_t s)
{
struct lo_node *n = (struct lo_node *) p;
return hash_string (n->name, s);
}
static bool
file_exists_p (const char *path)
{
return access (path, R_OK) == F_OK;
}
static bool
node_compare (const void *n1, const void *n2)
{
struct lo_node *node1 = (struct lo_node *) n1;
struct lo_node *node2 = (struct lo_node *) n2;
return strcmp (node1->name, node2->name) == 0 ? true : false;
}
static struct lo_node *
make_lo_node (const char *path, const char *name, bool dir_p)
{
struct lo_node *ret = malloc (sizeof (*ret));
if (ret == NULL)
{
errno = ENOMEM;
return NULL;
}
ret->lowerdir = NULL;
ret->parent = NULL;
ret->dirty = 0;
ret->low = 0;
ret->lookups = 0;
ret->do_unlink = 0;
ret->hidden = 0;
ret->do_rmdir = 0;
ret->not_exists = 0;
ret->name = strdup (name);
if (ret->name == NULL)
{
free (ret);
errno = ENOMEM;
return NULL;
}
ret->path = strdup (path);
if (ret->path == NULL)
{
free (ret->name);
free (ret);
errno = ENOMEM;
return NULL;
}
if (!dir_p)
ret->children = NULL;
else
{
ret->children = hash_initialize (10, NULL, node_hasher, node_compare, node_free);
if (ret->children == NULL)
{
free (ret->path);
free (ret->name);
free (ret);
errno = ENOMEM;
return NULL;
}
}
return ret;
}
static struct lo_node *
insert_node (struct lo_node *parent, struct lo_node *item, bool replace)
{
struct lo_node *old = NULL, *prev_parent = item->parent;
int ret;
if (prev_parent)
hash_delete (prev_parent->children, item);
if (replace)
hash_delete (parent->children, item);
ret = hash_insert_if_absent (parent->children, item, (const void **) &old);
if (ret < 0)
{
errno = ENOMEM;
return NULL;
}
if (ret == 0)
{
node_free (item);
return old;
}
item->parent = parent;
if (parent->lowerdir && item->lowerdir == NULL)
item->lowerdir = hash_lookup (parent->lowerdir->children, item);
return item;
}
static struct lo_node *
traverse_dir (char * const dir, struct lo_node *lower, bool low)
{
struct lo_node *root, *n, *parent;
int ret = -1;
char *const dirs[] = {dir, NULL};
FTS *fts = fts_open (dirs, FTS_NOSTAT | FTS_COMFOLLOW, NULL);
if (fts == NULL)
return NULL;
root = NULL;
while (1)
{
FTSENT *ent = fts_read (fts);
if (ent == NULL)
{
if (errno)
goto err;
break;
}
switch (ent->fts_info)
{
case FTS_D:
if (root == NULL)
{
root = make_lo_node (dir, "/", true);
root->lowerdir = lower;
root->low = low ? 1 : 0;
ent->fts_pointer = root;
}
else
{
n = make_lo_node (ent->fts_path, ent->fts_name, true);
ent->fts_pointer = n;
if (n == NULL)
goto err;
parent = (struct lo_node *) ent->fts_parent->fts_pointer;
if (insert_node (parent, n, false) == NULL)
goto err;
n->low = low ? 1 : 0;
}
break;
case FTS_DP:
break;
case FTS_F:
case FTS_SL:
case FTS_SLNONE:
case FTS_DEFAULT:
n = make_lo_node (ent->fts_path, ent->fts_name, false);
if (n == NULL)
goto err;
n->low = low ? 1 : 0;
parent = (struct lo_node *) ent->fts_parent->fts_pointer;
if (insert_node (parent, n, true) == NULL)
goto err;
break;
}
}
ret = 0;
err:
if (ret)
{
node_mark_all_free (root);
node_free (root);
root = NULL;
}
fts_close (fts);
return root;
}
static bool
has_prefix (const char *str, const char *pref)
{
while (1)
{
if (*pref == '\0')
return true;
if (*str == '\0')
return false;
if (*pref != *str)
return false;
str++;
pref++;
}
return false;
}
static struct lo_node *
merge_trees (struct lo_node *origin, struct lo_node *new)
{
struct lo_node *it;
struct lo_node **children;
size_t i, s;
if (!node_dirp (origin) || !node_dirp (new))
{
if (insert_node (origin->parent, new, true) == NULL)
return NULL;
return origin;
}
s = sizeof (*children) * hash_get_n_entries (new->children);
children = malloc (s);
if (children == NULL)
return NULL;
s = hash_get_entries (new->children, (void **) children, s);
for (i = s; i > 0; i--)
{
struct lo_node *prev;
it = children[i - 1];
prev = hash_lookup (origin->children, it);
if (has_prefix (it->name, ".wh."))
{
struct lo_node *rm;
char *name = it->name;
it->name = it->name + 4;
rm = hash_delete (origin->children, it);
it->name = name;
if (rm)
node_free (rm);
continue;
}
if (prev != NULL && node_dirp (origin) && node_dirp (it))
{
hash_delete (new->children, it);
if (merge_trees (prev, it) == NULL)
{
free (children);
return NULL;
}
}
else
{
hash_delete (new->children, it);
if (insert_node (origin, it, true) == NULL)
{
free (children);
return NULL;
}
}
}
node_free (new);
free (children);
return origin;
}
static struct lo_node *
reload_dir (struct lo_node *n, char *path, char *name, struct lo_node *lowerdir)
{
DIR *dp;
struct dirent *dent;
char *it;
int fd;
struct stat st;
struct lo_node *created = NULL;
Hash_table *whiteouts = NULL;
if (n)
{
n->path = path;
if (n->not_exists)
return n;
}
else
{
n = created = make_lo_node (path, name, true);
if (n == NULL)
return NULL;
}
n->lowerdir = lowerdir;
dp = opendir (path);
if (dp == NULL)
return NULL;
whiteouts = hash_initialize (10, NULL, str_hasher, str_compare, free);
if (whiteouts == NULL)
{
closedir (dp);
errno = ENOMEM;
return NULL;
}
fd = dirfd (dp);
while (dp && ((dent = readdir (dp)) != NULL))
{
bool dirp;
struct lo_node *child;
char b[PATH_MAX + 1];
struct lo_node key;
key.name = dent->d_name;
if (hash_lookup (n->children, &key))
continue;
if ((strcmp (dent->d_name, ".") == 0) || strcmp (dent->d_name, "..") == 0)
continue;
if (fstatat (fd, dent->d_name, &st, AT_SYMLINK_NOFOLLOW) < 0)
goto err;
sprintf (b, "%s/%s", path, dent->d_name);
dirp = st.st_mode & S_IFDIR;
if (has_prefix (dent->d_name, ".wh."))
{
char *tmp, *name = strdup (dent->d_name + 4);
if (name == NULL)
{
errno = ENOMEM;
closedir (dp);
hash_free (whiteouts);
return NULL;
}
tmp = hash_insert (whiteouts, name);
if (tmp == NULL)
{
free (name);
errno = ENOMEM;
closedir (dp);
hash_free (whiteouts);
return NULL;
}
continue;
}
child = make_lo_node (b, dent->d_name, dirp);
if (!child)
goto err;
if (lowerdir)
child->lowerdir = hash_lookup (lowerdir->children, &key);
if (dirp)
child->dirty = 1;
if (insert_node (n, child, false) == NULL)
{
node_free (child);
goto err;
}
}
closedir (dp);
for (it = hash_get_first (whiteouts); it; it = hash_get_next (whiteouts, it))
{
struct lo_node key, *tmp;
key.name = it;
tmp = (struct lo_node *) hash_delete (n->children, &key);
if (tmp)
node_free (tmp);
}
hash_free (whiteouts);
whiteouts = NULL;
n->dirty = 0;
return n;
err:
if (created)
node_free (created);
closedir (dp);
return NULL;
}
static struct lo_node *
read_dirs (char *path, struct lo_node *lower, bool low)
{
char *buf = NULL, *saveptr = NULL, *it;
struct lo_node *root = NULL;
if (path == NULL)
return NULL;
buf = strdup (path);
if (buf == NULL)
return NULL;
for (it = strtok_r (path, ":", &saveptr); it; it = strtok_r (NULL, ":", &saveptr))
{
char full_path[PATH_MAX + 1];
struct lo_node *node;
if (realpath (it, full_path) < 0)
return NULL;
node = traverse_dir (full_path, lower, low);
if (node == NULL)
{
free (buf);
return NULL;
}
if (root == NULL)
root = node;
else
{
node = merge_trees (root, node);
if (node == NULL)
{
free (buf);
node_free (root);
return NULL;
}
root = node;
}
}
free (buf);
return root;
}
static void
make_path (struct lo_node *node, const char *prefix, const char *suffix, char *b)
{
struct lo_node *it;
struct
{
size_t l;
const char *p;
}
parts[PATH_MAX + 1];
size_t i = 0;
if (suffix)
{
parts[i].l = strlen (suffix);
parts[i].p = suffix;
i++;
}
for (it = node; it->parent; it = it->parent)
{
parts[i].l = strlen (it->name);
parts[i].p = it->name;
i++;
}
if (prefix)
{
if (*prefix == '/')
prefix++;
parts[i].l = strlen (prefix);
parts[i].p = prefix;
i++;
}
for (; i > 0; i--)
{
*b++ = '/';
memcpy (b, parts[i - 1].p, parts[i - 1].l);
b += parts[i - 1].l;
}
*b = '\0';
}
static struct lo_node *
do_lookup_file (struct lo_data *lo, fuse_ino_t parent, const char *path)
{
char *saveptr = NULL, *it;
char *b;
struct lo_node *node;
struct lo_node *lowerdir;
if (parent == FUSE_ROOT_ID)
node = lo->root_upper;
else
node = (struct lo_node *) parent;
if (path == NULL)
return node;
lowerdir = node->lowerdir;
if (*path == '\0')
return node;
b = alloca (strlen (path));
strcpy (b, path);
for (it = strtok_r (b, "/", &saveptr); it; it = strtok_r (NULL, "/", &saveptr))
{
struct lo_node *next;
struct lo_node tmp;
if (node->dirty)
{
node = reload_dir (node, node->path, node->name, node->lowerdir);
if (node == NULL)
return node;
}
tmp.name = it;
if (lowerdir && lowerdir->children)
lowerdir = hash_lookup (lowerdir->children, &tmp);
else
lowerdir = NULL;
if (node->children == NULL && lowerdir == NULL)
return NULL;
next = hash_lookup (node->children, &tmp);
if (next != NULL)
node = next;
else
{
char b[PATH_MAX + 1];
if (lowerdir == NULL)
return NULL;
sprintf (b, "%s/.wh.%s", node->path, lowerdir->name);
if (file_exists_p (b))
return NULL;
sprintf (b, "%s/%s", node->path, lowerdir->name);
next = make_lo_node (b, lowerdir->name, lowerdir->children != NULL);
if (!next)
return NULL;
next->not_exists = 1;
next = insert_node (node, next, false);
if (next == NULL)
return NULL;
}
node = next;
if (lowerdir)
assert (strcmp (node->name, lowerdir->name) == 0);
node->lowerdir = lowerdir;
}
return node;
}
static void
lo_lookup (fuse_req_t req, fuse_ino_t parent, const char *name)
{
struct fuse_entry_param e;
int err = 0;
struct lo_data *lo = lo_data (req);
struct lo_node *node;
if (lo_debug (req))
fprintf (stderr, "lo_lookup(parent=%" PRIu64 ", name=%s)\n",
parent, name);
memset (&e, 0, sizeof (e));
node = do_lookup_file (lo, parent, name);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
if (node->dirty && !node->not_exists)
{
node = reload_dir (node, get_node_path (node), node->name, node->lowerdir);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
}
err = rpl_stat (req, node, &e.attr);
if (err)
{
fuse_reply_err (req, errno);
return;
}
e.ino = (fuse_ino_t) node;
node->lookups++;
e.attr_timeout = ATTR_TIMEOUT;
e.entry_timeout = ENTRY_TIMEOUT;
fuse_reply_entry (req, &e);
}
struct lo_dirp
{
struct lo_data *lo;
fuse_ino_t parent;
Hash_table *elements;
char **tbl;
size_t tbl_size;
size_t offset;
};
static struct lo_dirp *
lo_dirp (struct fuse_file_info *fi)
{
return (struct lo_dirp *) (uintptr_t) fi->fh;
}
static void
lo_opendir (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
int error;
DIR *dp = NULL;
char *it;
struct lo_node *node;
struct lo_node *low = NULL;
struct lo_data *lo = lo_data (req);
struct lo_dirp *d = calloc (1, sizeof (struct lo_dirp));
struct dirent *dent;
Hash_table *whiteouts = NULL;
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
errno = ENOENT;
goto out_errno;
}
if (node->dirty)
{
node = reload_dir (node, node->path, node->name, node->lowerdir);
if (node == NULL)
goto out_errno;
}
d->parent = ino;
d->offset = 0;
d->elements = hash_initialize (10, NULL, str_hasher, str_compare, free);
if (d->elements == NULL)
{
errno = ENOMEM;
goto out_errno;
}
if (node->lowerdir && node->lowerdir->children)
low = node->lowerdir;
else if (node->low && node->children)
low = node;
if (low)
{
struct lo_node *it;
for (it = hash_get_first (low->children); it; it = hash_get_next (low->children, it))
{
char *i;
char *el;
struct lo_node *n;
n = do_lookup_file (lo, ino, it->name);
if (n == NULL)
continue;
el = strdup (it->name);
if (el == NULL)
{
errno = ENOMEM;
goto out_errno;
}
i = hash_insert (d->elements, el);
if (i == NULL)
{
errno = ENOMEM;
goto out_errno;
}
if (i != el)
free (el);
}
}
if (!node->low)
{
dp = opendir (node->path);
if (dp == NULL && errno != ENOENT)
goto out_errno;
whiteouts = hash_initialize (10, NULL, str_hasher, str_compare, free);
if (whiteouts == NULL)
{
errno = ENOMEM;
goto out_errno;
}
while (dp && ((dent = readdir (dp)) != NULL))
{
char *el = NULL;
char *prev;
struct lo_node *l;
if (strcmp (dent->d_name, ".") == 0)
l = node;
else if (strcmp (dent->d_name, "..") == 0)
{
if (node->parent)
l = node->parent;
else
continue;
}
else
{
l = do_lookup_file (lo, NODE_TO_INODE (node), dent->d_name);
}
if (has_prefix (dent->d_name, ".wh."))
{
char *tmp, *name = strdup (dent->d_name + 4);
if (name == NULL)
{
errno = ENOMEM;
goto out_errno;
}
tmp = hash_insert (whiteouts, name);
if (tmp == NULL)
{
free (name);
errno = ENOMEM;
goto out_errno;
}
if (tmp != name)
free (name);
continue;
}
if (l == NULL)
continue;
el = strdup (dent->d_name);
if (el == NULL)
{
errno = ENOMEM;
goto out_errno;
}
prev = hash_insert (d->elements, el);
if (prev == NULL)
{
errno = ENOMEM;
goto out_errno;
}
if (prev != el)
free (el);
}
if (dp)
{
closedir (dp);
dp = NULL;
}
for (it = hash_get_first (whiteouts); it; it = hash_get_next (whiteouts, it))
{
char *tmp = hash_delete (d->elements, it);
if (tmp)
free (tmp);
}
hash_free (whiteouts);
whiteouts = NULL;
}
d->tbl_size = hash_get_n_entries (d->elements);
d->tbl = malloc (sizeof (char *) * d->tbl_size);
if (d->tbl == NULL)
{
errno = ENOMEM;
goto out_errno;
}
hash_get_entries (d->elements, (void **) d->tbl, d->tbl_size);
fi->fh = (uintptr_t) d;
fuse_reply_open (req, fi);
return;
out_errno:
error = errno;
if (whiteouts)
hash_free (whiteouts);
if (dp)
closedir (dp);
if (d)
{
if (d->elements)
hash_free (d->elements);
if (d->tbl)
free (d->tbl);
free (d);
}
fuse_reply_err (req, error);
}
static void
lo_do_readdir (fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi, int plus)
{
struct lo_dirp *d = lo_dirp (fi);
size_t remaining = size;
char *p, *buffer = calloc (size, 1);
struct lo_data *lo = lo_data (req);
if (buffer == NULL)
{
fuse_reply_err (req, ENOMEM);
return;
}
p = buffer;
while (remaining > 0 && offset < d->tbl_size)
{
int ret;
size_t entsize;
struct stat st;
char *name = d->tbl[offset];
struct lo_node *node;
if (strcmp (name, ".") == 0)
{
node = do_lookup_file (lo, ino, NULL);
}
else if (strcmp (name, "..") == 0)
{
node = do_lookup_file (lo, ino, NULL);
if (node->parent)
node = node->parent;
else
{
offset++;
continue;
}
}
else
{
node = do_lookup_file (lo, ino, name);
if (node == NULL)
{
offset++;
continue;
}
}
ret = rpl_stat (req, node, &st);
if (ret < 0)
{
fuse_reply_err (req, errno);
goto exit;
}
if (!plus)
entsize = fuse_add_direntry (req, p, remaining, name, &st, offset + 1);
else
{
struct fuse_entry_param e;
memset (&e, 0, sizeof (e));
e.attr_timeout = ATTR_TIMEOUT;
e.entry_timeout = ENTRY_TIMEOUT;
e.ino = NODE_TO_INODE (node);
if ((strcmp (name, ".") != 0) && (strcmp (name, "..") != 0))
node->lookups++;
memcpy (&e.attr, &st, sizeof (st));
entsize = fuse_add_direntry_plus (req, p, remaining, name, &e, offset + 1);
}
p += entsize;
offset++;
if (entsize > remaining)
break;
remaining -= entsize;
}
fuse_reply_buf (req, buffer, size - remaining);
exit:
free (buffer);
}
static void
lo_readdir (fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi)
{
lo_do_readdir (req, ino, size, offset, fi, 0);
}
static void
lo_readdirplus (fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi)
{
lo_do_readdir (req, ino, size, offset, fi, 1);
}
static void
lo_releasedir (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
struct lo_dirp *d = lo_dirp (fi);
if (d->elements)
hash_free (d->elements);
free (d->tbl);
free (d);
fuse_reply_err (req, 0);
}
static void
lo_listxattr (fuse_req_t req, fuse_ino_t ino, size_t size)
{
ssize_t len;
struct lo_node *node;
struct lo_data *lo = lo_data (req);
char buf[1024];
if (lo_debug (req))
fprintf (stderr, "lo_listxattr(ino=%" PRIu64 ", size=%zu)\n", ino, size);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
len = llistxattr (get_node_path (node), buf, sizeof (buf));
if (len < 0)
fuse_reply_err (req, errno);
else if (size == 0)
fuse_reply_xattr (req, len);
else if (len <= size)
fuse_reply_buf (req, buf, len);
}
static void
lo_getxattr (fuse_req_t req, fuse_ino_t ino, const char *name, size_t size)
{
ssize_t len;
struct lo_node *node;
struct lo_data *lo = lo_data (req);
char buf[1024];
if (lo_debug (req))
fprintf (stderr, "lo_getxattr(ino=%" PRIu64 ", name=%s, size=%zu)\n", ino, name, size);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
len = lgetxattr (get_node_path (node), name, buf, sizeof (buf));
if (len < 0)
fuse_reply_err (req, errno);
else if (size == 0)
fuse_reply_xattr (req, len);
else if (len <= size)
fuse_reply_buf (req, buf, len);
}
static void
lo_access (fuse_req_t req, fuse_ino_t ino, int mask)
{
int ret;
struct lo_data *lo = lo_data (req);
struct lo_node *n = do_lookup_file (lo, ino, NULL);
if (lo_debug (req))
fprintf (stderr, "lo_access(ino=%" PRIu64 ", mask=%d)\n",
ino, mask);
ret = access (get_node_path (n), mask);
fuse_reply_err (req, ret < 0 ? errno : 0);
}
static int
create_directory (struct lo_data *lo, struct lo_node *src)
{
int ret;
struct stat st;
char *dest_path;
if (src == NULL)
return 0;
if (! src->not_exists)
return 0;
dest_path = src->path;
ret = lstat (src->lowerdir->path, &st);
if (ret < 0)
goto out;
ret = mkdir (dest_path, st.st_mode);
if (ret < 0 && errno == EEXIST)
{
ret = 0;
goto out;
}
else if (ret < 0 && errno == ENOENT)
{
ret = create_directory (lo, src->parent);
if (ret != 0)
goto out;
ret = mkdir (dest_path, st.st_mode);
if (ret < 0)
goto out;
ret = chown (dest_path, st.st_uid, st.st_gid);
}
out:
if (ret == 0)
{
src->not_exists = 0;
if (src->parent)
{
char wh[PATH_MAX];
sprintf (wh, "%s/.wh.%s", src->parent->path, src->name);
unlink (wh);
}
}
return ret;
}
static int
copyup (struct lo_data *lo, struct lo_node *node)
{
int saved_errno;
int ret = -1;
int dfd = -1, sfd = -1;
struct stat st;
int r;
const char *src = node->lowerdir->path;
const char *dst = node->path;
struct timespec times[2];
if (node->parent)
{
r = create_directory (lo, node->parent);
if (r < 0)
return r;
}
if (lstat (src, &st) < 0)
goto exit;
if (node->parent)
{
char whpath[PATH_MAX + 10];
sprintf (whpath, "%s/.wh.%s", node->parent->path, node->name);
if (unlink (whpath) < 0 && errno != ENOENT)
goto exit;
}
if ((st.st_mode & S_IFMT) == S_IFDIR)
{
ret = create_directory (lo, node);
if (ret < 0)
goto exit;
goto success;
}
if ((st.st_mode & S_IFMT) == S_IFLNK)
{
char p[PATH_MAX + 1];
ret = readlink (src, p, sizeof (p) - 1);
if (ret < 0)
goto exit;
p[ret] = '\0';
ret = symlink (p, dst);
if (ret < 0)
goto exit;
goto success;
}
sfd = open (src, O_RDONLY);
if (sfd < 0)
goto exit;
dfd = open (dst, O_WRONLY|O_CREAT, st.st_mode);
if (dfd < 0)
goto exit;
ret = fchown (dfd, st.st_uid, st.st_gid);
if (ret < 0)
goto exit;
for (;;)
{
int written;
int nread;
char buf[4096];
nread = TEMP_FAILURE_RETRY (read (sfd, buf, sizeof (buf)));
if (nread < 0)
goto exit;
if (nread == 0)
break;
written = 0;
{
r = TEMP_FAILURE_RETRY (write (dfd, buf + written, nread));
if (r < 0)
goto exit;
written += r;
nread -= r;
}
while (nread);
}
times[0] = st.st_atim;
times[1] = st.st_mtim;
if (futimens (dfd, times) < 0)
goto exit;
success:
ret = 0;
node->not_exists = 0;
exit:
saved_errno = errno;
if (sfd >= 0)
close (sfd);
if (dfd >= 0)
close (dfd);
errno = saved_errno;
return ret;
}
static struct lo_node *
get_node_up (struct lo_data *lo, struct lo_node *node)
{
int ret;
if (!node->lowerdir || !node->not_exists)
return node;
ret = copyup (lo, node);
if (ret < 0)
return NULL;
assert (has_prefix (node->path, lo->upperdir));
return node;
}
static size_t
count_dir_entries (struct lo_node *node)
{
size_t c = 0;
struct lo_node *it;
for (it = hash_get_first (node->children); it; it = hash_get_next (node->children, it))
{
if (strcmp (it->name, ".") == 0)
continue;
if (strcmp (it->name, "..") == 0)
continue;
c++;
}
return c;
}
static int
update_paths (struct lo_node *node)
{
struct lo_node *it;
if (node == NULL)
return 0;
if (node->parent)
{
free (node->path);
node->path = NULL;
if (asprintf (&node->path, "%s/%s", node->parent->path, node->name) < 0)
return -1;
}
if (node->children)
{
for (it = hash_get_first (node->children); it; it = hash_get_next (node->children, it))
{
if (update_paths (it) < 0)
return -1;
}
}
return 0;
}
static void
do_rm (fuse_req_t req, fuse_ino_t parent, const char *name, bool dirp)
{
struct lo_node *node;
struct lo_data *lo = lo_data (req);
struct lo_node *pnode;
int fd;
int ret = 0;
char whiteout_path[PATH_MAX + 10];
struct lo_node key, *rm;
node = do_lookup_file (lo, parent, name);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
if (! node->low)
{
if (! dirp)
node->do_unlink = 1;
else
{
DIR *dp;
size_t c = 0;
if (node->dirty)
{
node = reload_dir (node, node->path, node->name, node->lowerdir);
if (node == NULL)
{
fuse_reply_err (req, errno);
return;
}
}
if (node->children)
c = count_dir_entries (node);
if (c == 0 && node->lowerdir && node->lowerdir->children)
c = count_dir_entries (node->lowerdir);
if (c)
{
fuse_reply_err (req, ENOTEMPTY);
return;
}
dp = opendir (node->path);
if (dp)
{
struct dirent *dent;
while (dp && ((dent = readdir (dp)) != NULL))
{
if (strcmp (dent->d_name, ".") == 0)
continue;
if (strcmp (dent->d_name, "..") == 0)
continue;
if (unlinkat (dirfd (dp), dent->d_name, 0) < 0)
unlinkat (dirfd (dp), dent->d_name, AT_REMOVEDIR);
}
closedir (dp);
}
node->do_rmdir = 1;
}
}
pnode = do_lookup_file (lo, parent, NULL);
if (pnode == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
pnode = get_node_up (lo, pnode);
if (pnode == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
sprintf (whiteout_path, "%s/.wh.%s", get_node_path (pnode), name);
fd = creat (whiteout_path, 0700);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
close (fd);
ret = 0;
key.name = (char *) name;
rm = hash_delete (pnode->children, &key);
if (rm)
{
hide_node (lo, rm);
node_free (rm);
}
fuse_reply_err (req, ret);
}
static void
lo_unlink (fuse_req_t req, fuse_ino_t parent, const char *name)
{
if (lo_debug (req))
fprintf (stderr, "lo_unlink(parent=%" PRIu64 ", name=%s)\n",
parent, name);
do_rm (req, parent, name, false);
}
static void
lo_rmdir (fuse_req_t req, fuse_ino_t parent, const char *name)
{
if (lo_debug (req))
fprintf (stderr, "lo_rmdir(parent=%" PRIu64 ", name=%s)\n",
parent, name);
do_rm (req, parent, name, true);
}
static void
lo_setxattr (fuse_req_t req, fuse_ino_t ino, const char *name,
const char *value, size_t size, int flags)
{
struct lo_data *lo = lo_data (req);
struct lo_node *node;
if (lo_debug (req))
fprintf (stderr, "lo_setxattr(ino=%" PRIu64 "s, name=%s, value=%s, size=%zu, flags=%d)\n", ino, name,
value, size, flags);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
node = get_node_up (lo, node);
if (node == NULL)
{
fuse_reply_err (req, errno);
return;
}
if (setxattr (node->path, name, value, size, flags) < 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_err (req, 0);
}
static void
lo_removexattr (fuse_req_t req, fuse_ino_t ino, const char *name)
{
struct lo_node *node;
struct lo_data *lo = lo_data (req);
if (lo_debug (req))
fprintf (stderr, "lo_removexattr(ino=%" PRIu64 "s, name=%s)\n", ino, name);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
node = get_node_up (lo, node);
if (node == NULL)
{
fuse_reply_err (req, errno);
return;
}
if (removexattr (node->path, name) < 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_err (req, 0);
}
static int
lo_do_open (fuse_req_t req, fuse_ino_t parent, const char *name, int flags, mode_t mode)
{
struct lo_data *lo = lo_data (req);
struct lo_node *n;
bool readonly = (flags & (O_APPEND | O_RDWR | O_WRONLY | O_CREAT | O_TRUNC)) == 0;
char path[PATH_MAX + 10];
int fd, ret;
flags |= O_NOFOLLOW;
if (name && has_prefix (name, ".wh."))
{
errno = EINVAL;
return - 1;
}
n = do_lookup_file (lo, parent, name);
if (n && n->hidden)
{
n = NULL;
}
if (n && (flags & O_CREAT))
{
errno = EEXIST;
return -1;
}
if (!n)
{
struct lo_node *p;
if ((flags & O_CREAT) == 0)
{
errno = ENOENT;
return -1;
}
p = do_lookup_file (lo, parent, NULL);
if (p == NULL)
{
errno = ENOENT;
return -1;
}
p = get_node_up (lo, p);
if (p == NULL)
{
return -1;
}
sprintf (path, "%s/.wh.%s", p->path, name);
unlink (path);
sprintf (path, "%s/%s", p->path, name);
unlink (path);
fd = open (path, flags, mode);
if (fd < 0)
{
return -1;
}
n = make_lo_node (path, name, false);
if (n == NULL)
{
p->dirty = 1;
errno = ENOMEM;
return -1;
}
if (insert_node (p, n, true) == NULL)
{
p->dirty = 1;
node_free (n);
errno = ENOMEM;
return -1;
}
return fd;
}
/* readonly, we can use both lowerdir and upperdir. */
if (readonly)
{
ret = open (get_node_path (n), flags, mode);
if (ret < 0)
return ret;
return ret;
}
else
{
n = get_node_up (lo, n);
if (n == NULL)
return -1;
fd = open (n->path, flags, mode);
if (fd < 0)
return fd;
return fd;
}
}
static void
lo_read (fuse_req_t req, fuse_ino_t ino, size_t size,
off_t offset, struct fuse_file_info *fi)
{
struct fuse_bufvec buf = FUSE_BUFVEC_INIT (size);
if (lo_debug (req))
fprintf (stderr, "lo_read(ino=%" PRIu64 ", size=%zd, "
"off=%lu)\n", ino, size, (unsigned long) offset);
buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
buf.buf[0].fd = fi->fh;
buf.buf[0].pos = offset;
fuse_reply_data (req, &buf, FUSE_BUF_SPLICE_MOVE);
}
static void
lo_write_buf (fuse_req_t req, fuse_ino_t ino,
struct fuse_bufvec *in_buf, off_t off,
struct fuse_file_info *fi)
{
(void) ino;
ssize_t res;
struct fuse_bufvec out_buf = FUSE_BUFVEC_INIT (fuse_buf_size (in_buf));
out_buf.buf[0].flags = FUSE_BUF_IS_FD | FUSE_BUF_FD_SEEK;
out_buf.buf[0].fd = fi->fh;
out_buf.buf[0].pos = off;
if (lo_debug (req))
fprintf (stderr, "lo_write_buf(ino=%" PRIu64 ", size=%zd, off=%lu, fd=%d)\n",
ino, out_buf.buf[0].size, (unsigned long) off, (int) fi->fh);
errno = 0;
res = fuse_buf_copy (&out_buf, in_buf, 0);
if (res < 0)
fuse_reply_err (req, errno);
else
fuse_reply_write (req, (size_t) res);
}
static void
lo_release (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
(void) ino;
close (fi->fh);
fuse_reply_err (req, 0);
}
static int
do_getattr (fuse_req_t req, struct fuse_entry_param *e, struct lo_node *node)
{
int err = 0;
memset (e, 0, sizeof (*e));
err = rpl_stat (req, node, &e->attr);
if (err < 0)
return err;
e->ino = (fuse_ino_t) node;
e->attr_timeout = ATTR_TIMEOUT;
e->entry_timeout = ENTRY_TIMEOUT;
return 0;
}
static void
lo_create (fuse_req_t req, fuse_ino_t parent, const char *name,
mode_t mode, struct fuse_file_info *fi)
{
int fd;
struct fuse_entry_param e;
struct lo_data *lo = lo_data (req);
struct lo_node *node;
if (lo_debug (req))
fprintf (stderr, "lo_create(parent=%" PRIu64 ", name=%s)\n",
parent, name);
fi->flags = fi->flags | O_CREAT;
fd = lo_do_open (req, parent, name, fi->flags, mode);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
node = do_lookup_file (lo, parent, name);
if (node == NULL || do_getattr (req, &e, node) < 0)
{
close (fd);
fuse_reply_err (req, errno);
return;
}
fi->fh = fd;
node->lookups++;
fuse_reply_create (req, &e, fi);
}
static void
lo_open (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
int fd;
if (lo_debug (req))
fprintf (stderr, "lo_open(ino=%" PRIu64 "s)\n", ino);
fd = lo_do_open (req, ino, NULL, fi->flags, 0700);
if (fd < 0)
{
fuse_reply_err (req, errno);
return;
}
fi->fh = fd;
fuse_reply_open (req, fi);
}
static void
lo_getattr (fuse_req_t req, fuse_ino_t ino, struct fuse_file_info *fi)
{
struct lo_data *lo = lo_data (req);
struct lo_node *node;
struct fuse_entry_param e;
if (lo_debug (req))
fprintf (stderr, "lo_getattr(ino=%" PRIu64 "s)\n", ino);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
if (do_getattr (req, &e, node) < 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_attr (req, &e.attr, ENTRY_TIMEOUT);
}
static void
lo_setattr (fuse_req_t req, fuse_ino_t ino, struct stat *attr, int to_set, struct fuse_file_info *fi)
{
struct lo_data *lo = lo_data (req);
struct lo_node *node;
struct fuse_entry_param e;
struct stat old_st;
struct timespec times[2];
uid_t uid;
gid_t gid;
if (lo_debug (req))
fprintf (stderr, "lo_setattr(ino=%" PRIu64 "s, to_set=%d)\n", ino, to_set);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
node = get_node_up (lo, node);
if (node == NULL)
{
fuse_reply_err (req, errno);
return;
}
if (lstat (node->path, &old_st) < 0)
{
fuse_reply_err (req, errno);
return;
}
if (to_set & FUSE_SET_ATTR_CTIME)
{
fuse_reply_err (req, EPERM);
return;
}
times[0].tv_sec = UTIME_OMIT;
times[1].tv_sec = UTIME_OMIT;
if (to_set & FUSE_SET_ATTR_ATIME)
times[0] = attr->st_atim;
else if (to_set & FUSE_SET_ATTR_ATIME_NOW)
times[0].tv_sec = UTIME_NOW;
if (to_set & FUSE_SET_ATTR_MTIME)
times[1] = attr->st_mtim;
else if (to_set & FUSE_SET_ATTR_MTIME_NOW)
times[1].tv_sec = UTIME_NOW;
if (times[0].tv_sec != UTIME_OMIT || times[1].tv_sec != UTIME_OMIT)
{
if ((utimensat (AT_FDCWD, node->path, times, AT_SYMLINK_NOFOLLOW) < 0))
{
fuse_reply_err (req, errno);
return;
}
}
if ((to_set & FUSE_SET_ATTR_MODE) && chmod (node->path, attr->st_mode) < 0)
{
fuse_reply_err (req, errno);
return;
}
if ((to_set & FUSE_SET_ATTR_SIZE) && truncate (node->path, attr->st_size) < 0)
{
fuse_reply_err (req, errno);
return;
}
uid = old_st.st_uid;
gid = old_st.st_gid;
if (to_set & FUSE_SET_ATTR_UID)
uid = get_uid (lo, attr->st_uid);
if (to_set & FUSE_SET_ATTR_GID)
gid = get_gid (lo, attr->st_gid);
if (uid != old_st.st_uid || gid != old_st.st_gid)
{
if (lchown (node->path, uid, gid) < 0)
{
fuse_reply_err (req, errno);
return;
}
}
if (do_getattr (req, &e, node) < 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_attr (req, &e.attr, ENTRY_TIMEOUT);
}
static void
lo_link (fuse_req_t req, fuse_ino_t ino, fuse_ino_t newparent, const char *newname)
{
struct lo_data *lo = lo_data (req);
struct lo_node *node, *newparentnode, *destnode;
char path[PATH_MAX + 10];
int ret;
struct fuse_entry_param e;
if (lo_debug (req))
fprintf (stderr, "lo_link(ino=%" PRIu64 "s, newparent=%" PRIu64 "s, newname=%s)\n", ino, newparent, newname);
node = do_lookup_file (lo, newparent, newname);
if (node != NULL)
{
fuse_reply_err (req, EEXIST);
return;
}
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
node = get_node_up (lo, node);
if (node == NULL)
{
fuse_reply_err (req, errno);
return;
}
newparentnode = do_lookup_file (lo, newparent, NULL);
if (newparentnode == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
destnode = do_lookup_file (lo, newparent, newname);
if (destnode)
{
fuse_reply_err (req, EEXIST);
return;
}
newparentnode = get_node_up (lo, newparentnode);
if (newparentnode == NULL)
{
fuse_reply_err (req, errno);
return;
}
sprintf (path, "%s/.wh.%s", newparentnode->path, newname);
if (unlink (path) < 0 && errno != ENOENT)
{
fuse_reply_err (req, errno);
return;
}
sprintf (path, "%s/%s", newparentnode->path, newname);
if (link (get_node_path (node), path) < 0)
{
fuse_reply_err (req, errno);
return;
}
node = make_lo_node (path, newname, false);
if (node == NULL)
{
fuse_reply_err (req, ENOMEM);
return;
}
if (insert_node (newparentnode, node, true) == NULL)
{
node_free (node);
fuse_reply_err (req, ENOMEM);
return;
}
memset (&e, 0, sizeof (e));
ret = rpl_stat (req, node, &e.attr);
if (ret)
{
fuse_reply_err (req, errno);
return;
}
e.ino = (fuse_ino_t) node;
node->lookups++;
e.attr_timeout = ATTR_TIMEOUT;
e.entry_timeout = ENTRY_TIMEOUT;
fuse_reply_entry (req, &e);
}
static void
lo_symlink (fuse_req_t req, const char *link, fuse_ino_t parent, const char *name)
{
struct lo_data *lo = lo_data (req);
struct lo_node *pnode, *node;
char path[PATH_MAX + 10];
int ret;
struct fuse_entry_param e;
if (lo_debug (req))
fprintf (stderr, "lo_symlink(link=%s, ino=%" PRIu64 "s, name=%s)\n", link, parent, name);
pnode = do_lookup_file (lo, parent, NULL);
if (pnode == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
pnode = get_node_up (lo, pnode);
if (pnode == NULL)
{
fuse_reply_err (req, errno);
return;
}
node = do_lookup_file (lo, parent, name);
if (node != NULL)
{
fuse_reply_err (req, EEXIST);
return;
}
sprintf (path, "%s/.wh.%s", pnode->path, name);
if (unlink (path) < 0 && errno != ENOENT)
{
fuse_reply_err (req, errno);
return;
}
sprintf (path, "%s/%s", pnode->path, name);
ret = symlink (link, path);
if (ret < 0)
{
fuse_reply_err (req, errno);
return;
}
node = make_lo_node (path, name, false);
if (node == NULL)
{
fuse_reply_err (req, ENOMEM);
return;
}
if (insert_node (pnode, node, true) == NULL)
{
node_free (node);
fuse_reply_err (req, ENOMEM);
return;
}
memset (&e, 0, sizeof (e));
ret = rpl_stat (req, node, &e.attr);
if (ret)
{
fuse_reply_err (req, errno);
return;
}
e.ino = (fuse_ino_t) node;
node->lookups++;
e.attr_timeout = ATTR_TIMEOUT;
e.entry_timeout = ENTRY_TIMEOUT;
fuse_reply_entry (req, &e);
}
static
void lo_flock (fuse_req_t req, fuse_ino_t ino,
struct fuse_file_info *fi, int op)
{
int ret, fd;
if (lo_debug (req))
fprintf (stderr, "lo_flock(ino=%" PRIu64 "s, op=%d)\n", ino, op);
fd = fi->fh;
ret = flock (fd, op);
fuse_reply_err (req, ret == 0 ? 0 : errno);
}
/* used to recover a failed lo_rename. */
static void
unhide_node (struct lo_node *node, struct lo_node *parent)
{
char b[PATH_MAX];
if (node->path == NULL)
return;
sprintf (b, "%s/%s", parent->path, node->name);
rename (node->path, b);
free (node->path);
node->path = strdup (b);
insert_node (parent, node, true);
}
static struct lo_node *
get_node_up_rec (struct lo_data *lo, struct lo_node *node)
{
int ret;
struct lo_node *it;
struct lo_node *l;
if (node->children)
{
for (it = hash_get_first (node->children); it; it = hash_get_next (node->children, it))
{
l = get_node_up_rec (lo, it);
if (l == NULL)
return NULL;
}
}
if (node->lowerdir && node->lowerdir->children)
{
for (it = hash_get_first (node->lowerdir->children); it; it = hash_get_next (node->lowerdir->children, it))
{
l = do_lookup_file (lo, NODE_TO_INODE (node), it->name);
if (l)
{
l = get_node_up_rec (lo, l);
if (l == NULL)
return NULL;
}
}
}
return get_node_up (lo, node);
}
static void
lo_rename (fuse_req_t req, fuse_ino_t parent, const char *name,
fuse_ino_t newparent, const char *newname,
unsigned int flags)
{
struct lo_node *pnode, *node, *destnode, *destpnode;
struct lo_data *lo = lo_data (req);
int ret;
int saved_errno;
char path[PATH_MAX + 1];
int srcfd = -1;
int destfd = -1;
struct lo_node key, *rm = NULL;
if (lo_debug (req))
fprintf (stderr, "lo_rename(ino=%" PRIu64 "s, name=%s , ino=%" PRIu64 "s, name=%s)\n", parent, name, newparent, newname);
node = do_lookup_file (lo, parent, name);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
pnode = node->parent;
destpnode = do_lookup_file (lo, newparent, NULL);
destnode = NULL;
pnode = get_node_up (lo, pnode);
if (pnode == NULL)
goto error;
ret = open (pnode->path, O_DIRECTORY);
if (ret < 0)
goto error;
srcfd = ret;
destpnode = get_node_up (lo, destpnode);
if (destpnode == NULL)
goto error;
ret = open (destpnode->path, O_DIRECTORY);
if (ret < 0)
goto error;
destfd = ret;
destnode = do_lookup_file (lo, newparent, newname);
node = get_node_up_rec (lo, node);
if (node == NULL)
goto error;
if (flags & RENAME_EXCHANGE)
{
if (destnode == NULL)
{
errno = ENOENT;
goto error;
}
destnode = get_node_up_rec (lo, destnode);
if (destnode == NULL)
goto error;
}
else
{
key.name = (char *) newname;
if (flags & RENAME_NOREPLACE)
{
rm = hash_lookup (destpnode->children, &key);
if (rm)
{
errno = EEXIST;
goto error;
}
}
if (destnode != NULL && node_dirp (destnode))
{
errno = EISDIR;
goto error;
}
rm = hash_delete (destpnode->children, &key);
if (rm)
{
hide_node (lo, rm);
node_free (rm);
}
}
ret = syscall (SYS_renameat2, srcfd, name, destfd, newname, flags);
if (ret < 0)
{
if (rm)
unhide_node (rm, destpnode);
pnode->dirty = destpnode->dirty = 1;
goto error;
}
if (flags & RENAME_EXCHANGE)
{
struct lo_node *rm1, *rm2;
char *tmp;
rm1 = hash_delete (destpnode->children, destnode);
rm2 = hash_delete (pnode->children, node);
tmp = node->path;
node->path = destnode->path;
destnode->path = tmp;
tmp = node->name;
node->name = destnode->name;
destnode->name = tmp;
if (insert_node (destpnode, node, true) == NULL)
{
node_free (rm1);
node_free (rm2);
goto error;
}
if (insert_node (pnode, destnode, true) == NULL)
{
node_free (rm1);
node_free (rm2);
goto error;
}
if ((update_paths (node) < 0) || (update_paths (destnode) < 0))
goto error;
}
else
{
int fd;
struct lo_node *rm;
sprintf (path, ".wh.%s", name);
fd = openat (srcfd, path, O_CREAT, 0700);
if (fd < 0)
goto error;
close (fd);
key.name = (char *) name;
hash_delete (pnode->children, &key);
free (node->name);
node->name = strdup (newname);
if (node->name == NULL)
goto error;
if (insert_node (destpnode, node, true) == NULL)
goto error;
if (update_paths (node) < 0)
goto error;
}
sprintf (path, ".wh.%s", newname);
if (unlinkat (destfd, path, 0) < 0 && errno != ENOENT)
goto error;
error:
saved_errno = errno;
if (srcfd >= 0)
close (srcfd);
if (destfd >= 0)
close (destfd);
errno = saved_errno;
fuse_reply_err (req, ret == 0 ? 0 : errno);
}
static void
lo_statfs (fuse_req_t req, fuse_ino_t ino)
{
int ret;
struct statvfs sfs;
struct lo_data *lo = lo_data (req);
if (lo_debug (req))
fprintf (stderr, "lo_statfs(ino=%" PRIu64 "s)\n", ino);
ret = statvfs (lo->upperdir, &sfs);
if (ret < 0)
{
fuse_reply_err (req, errno);
return;
}
fuse_reply_statfs (req, &sfs);
}
static void
lo_readlink (fuse_req_t req, fuse_ino_t ino)
{
struct lo_node *node;
struct lo_data *lo = lo_data (req);
int ret = 0;
char buf[PATH_MAX + 1];
if (lo_debug (req))
fprintf (stderr, "lo_readlink(ino=%" PRIu64 "s)\n", ino);
node = do_lookup_file (lo, ino, NULL);
if (node == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
ret = readlink (get_node_path (node), buf, sizeof (buf));
if (ret == -1)
{
fuse_reply_err (req, errno);
return;
}
if (ret == sizeof (buf))
{
fuse_reply_err (req, ENAMETOOLONG);
return;
}
buf[ret] = '\0';
fuse_reply_readlink (req, buf);
}
static int
hide_all (struct lo_node *node)
{
char b[PATH_MAX];
struct lo_node *it;
if (node->lowerdir == NULL || node->lowerdir->children == NULL)
return 0;
for (it = hash_get_first (node->lowerdir->children); it; it = hash_get_next (node->lowerdir->children, it))
{
int fd;
sprintf (b, "%s/.wh.%s", node->path, it->name);
fd = open (b, O_CREAT, 0700);
if (fd < 0 && errno != EEXIST)
return fd;
close (fd);
}
return 0;
}
static void
lo_mkdir (fuse_req_t req, fuse_ino_t parent, const char *name, mode_t mode)
{
struct lo_node *node;
struct lo_data *lo = lo_data (req);
struct lo_node *pnode;
int ret = 0;
char path[PATH_MAX + 10];
char whiteout_path[PATH_MAX + 16];
struct fuse_entry_param e;
if (lo_debug (req))
fprintf (stderr, "lo_mkdir(ino=%" PRIu64 ", name=%s, mode=%d)\n",
parent, name, mode);
node = do_lookup_file (lo, parent, name);
if (node != NULL)
{
fuse_reply_err (req, EEXIST);
return;
}
pnode = do_lookup_file (lo, parent, NULL);
if (pnode == NULL)
{
fuse_reply_err (req, ENOENT);
return;
}
pnode = get_node_up (lo, pnode);
if (pnode == NULL)
{
fuse_reply_err (req, errno);
return;
}
sprintf (path, "%s/%s", pnode->path, name);
rmdir (path);
ret = mkdir (path, mode);
if (ret < 0)
{
fuse_reply_err (req, errno);
return;
}
node = make_lo_node (path, name, true);
if (node == NULL)
{
fuse_reply_err (req, ENOMEM);
return;
}
if (insert_node (pnode, node, true) == NULL)
{
node_free (node);
fuse_reply_err (req, ENOMEM);
return;
}
ret = hide_all (node);
if (ret < 0)
{
fuse_reply_err (req, errno);
return;
}
sprintf (whiteout_path, "%s/.wh.%s", pnode->path, name);
ret = unlink (whiteout_path);
if (ret < 0 && errno != ENOENT)
{
fuse_reply_err (req, errno);
return;
}
memset (&e, 0, sizeof (e));
ret = rpl_stat (req, node, &e.attr);
if (ret)
{
fuse_reply_err (req, errno);
return;
}
e.ino = (fuse_ino_t) node;
e.attr_timeout = ATTR_TIMEOUT;
e.entry_timeout = ENTRY_TIMEOUT;
node->lookups++;
fuse_reply_entry (req, &e);
}
static void
lo_fsync (fuse_req_t req, fuse_ino_t ino, int datasync, struct fuse_file_info *fi)
{
int ret, fd;
if (lo_debug (req))
fprintf (stderr, "lo_fsync(ino=%" PRIu64 ", datasync=%d, fi=%p)\n",
ino, datasync, fi);
fd = fi->fh;
ret = datasync ? fdatasync (fd) : fsync (fd);
fuse_reply_err (req, ret == 0 ? 0 : errno);
}
static struct fuse_lowlevel_ops lo_oper = {
.statfs = lo_statfs,
.access = lo_access,
.getxattr = lo_getxattr,
.removexattr = lo_removexattr,
.setxattr = lo_setxattr,
.listxattr = lo_listxattr,
.init = lo_init,
.lookup = lo_lookup,
.forget = lo_forget,
.getattr = lo_getattr,
.readlink = lo_readlink,
.opendir = lo_opendir,
.readdir = lo_readdir,
.readdirplus = lo_readdirplus,
.releasedir = lo_releasedir,
.create = lo_create,
.open = lo_open,
.release = lo_release,
.read = lo_read,
.write_buf = lo_write_buf,
.unlink = lo_unlink,
.rmdir = lo_rmdir,
.setattr = lo_setattr,
.symlink = lo_symlink,
.rename = lo_rename,
.mkdir = lo_mkdir,
.link = lo_link,
.fsync = lo_fsync,
.flock = lo_flock,
};
static int
fuse_opt_proc (void *data, const char *arg, int key, struct fuse_args *outargs)
{
if (strcmp (arg, "-f") == 0)
return 1;
if (strcmp (arg, "--debug") == 0)
return 1;
/* Ignore unknown arguments. */
if (key == -1)
return 0;
return 1;
}
int
main (int argc, char *argv[])
{
struct fuse_args args = FUSE_ARGS_INIT (argc, argv);
struct fuse_session *se;
struct fuse_cmdline_opts opts;
struct lo_data lo = {.debug = 0,
.uid = -1,
.gid = -1,
.root_lower = NULL,
.root_upper = NULL,
.lowerdir = NULL,
};
int ret = -1;
unsetenv ("TMPDIR");
if (fuse_opt_parse (&args, &lo, lo_opts, fuse_opt_proc) == -1)
return 1;
if (fuse_parse_cmdline (&args, &opts) != 0)
return 1;
if (opts.show_help)
{
printf ("usage: %s [options] <mountpoint>\n\n", argv[0]);
fuse_cmdline_help ();
fuse_lowlevel_help ();
ret = 0;
goto err_out1;
}
else if (opts.show_version)
{
printf ("FUSE library version %s\n", fuse_pkgversion ());
fuse_lowlevel_version ();
ret = 0;
goto err_out1;
}
lo.debug = opts.debug;
if (lo.upperdir != NULL)
{
char full_path[PATH_MAX + 1];
if (realpath (lo.upperdir, full_path) < 0)
goto err_out1;
lo.upperdir = strdup (full_path);
if (lo.upperdir == NULL)
goto err_out1;
}
else
{
char *up = strdup ("/tmp/containerfs.XXXXXX");
int ret = mkstemp (up);
if (ret < 0)
goto err_out1;
close (ret);
lo.upperdir = up;
}
printf ("UID=%i\n", lo.uid);
printf ("GID=%i\n", lo.gid);
printf ("UPPERDIR=%s\n", lo.upperdir);
printf ("WORKDIR=%s\n", lo.workdir);
printf ("LOWERDIR=%s\n", lo.lowerdir);
printf ("MOUNTPOINT=%s\n", opts.mountpoint);
lo.root_lower = read_dirs (lo.lowerdir, NULL, true);
if (lo.root_lower == NULL)
error (EXIT_FAILURE, errno, "cannot read lower dirs");
lo.root_upper = reload_dir (NULL, lo.upperdir, "/", lo.root_lower);
if (lo.root_upper == NULL)
error (EXIT_FAILURE, errno, "cannot read upper dir");
lo.root_upper->lookups = 2;
lo.root_upper->lowerdir = lo.root_lower;
if (lo.workdir)
{
char path[PATH_MAX + 1];
if (realpath (lo.workdir, path) < 0)
goto err_out1;
mkdir (path, 0700);
strcat (path, "/work");
mkdir (path, 0700);
free (lo.workdir);
lo.workdir = strdup (path);
}
se = fuse_session_new (&args, &lo_oper, sizeof (lo_oper), &lo);
lo.se = se;
if (se == NULL)
goto err_out1;
if (fuse_set_signal_handlers (se) != 0)
goto err_out2;
if (fuse_session_mount (se, opts.mountpoint) != 0)
goto err_out3;
fuse_daemonize (opts.foreground);
ret = fuse_session_loop (se);
fuse_session_unmount (se);
err_out3:
fuse_remove_signal_handlers (se);
err_out2:
fuse_session_destroy (se);
err_out1:
node_mark_all_free (lo.root_lower);
node_mark_all_free (lo.root_upper);
node_free (lo.root_lower);
node_free (lo.root_upper);
free (opts.mountpoint);
fuse_opt_free_args (&args);
return ret ? 1 : 0;
}
Reference in New Issue View Git Blame Copy Permalink