change indenting

2 files changed, 969 insertions, 965 deletions

diff --git a/lib/modules/iconv.c b/lib/modules/iconv.c
index 350a472..c0e2b80 100644
--- a/lib/modules/iconv.c
+++ b/lib/modules/iconv.c
@@ -1,9 +1,9 @@
 /*
-    fuse iconv module: file name charset conversion
-    Copyright (C) 2007  Miklos Szeredi <miklos@szeredi.hu>
+  fuse iconv module: file name charset conversion
+  Copyright (C) 2007  Miklos Szeredi <miklos@szeredi.hu>
 
-    This program can be distributed under the terms of the GNU LGPLv2.
-    See the file COPYING.LIB
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
 */
 
 #define FUSE_USE_VERSION 26
@@ -20,689 +20,690 @@
 #include <langinfo.h>
 
 struct iconv {
-    struct fuse_fs *next;
-    pthread_mutex_t lock;
-    char *from_code;
-    char *to_code;
-    iconv_t tofs;
-    iconv_t fromfs;
+	struct fuse_fs *next;
+	pthread_mutex_t lock;
+	char *from_code;
+	char *to_code;
+	iconv_t tofs;
+	iconv_t fromfs;
 };
 
 struct iconv_dh {
-    struct iconv *ic;
-    void *prev_buf;
-    fuse_fill_dir_t prev_filler;
+	struct iconv *ic;
+	void *prev_buf;
+	fuse_fill_dir_t prev_filler;
 };
 
 static struct iconv *iconv_get(void)
 {
-    return fuse_get_context()->private_data;
+	return fuse_get_context()->private_data;
 }
 
 static int iconv_convpath(struct iconv *ic, const char *path, char **newpathp,
-                          int fromfs)
-{
-    size_t pathlen = strlen(path);
-    size_t newpathlen = pathlen * 4;
-    char *newpath = malloc(newpathlen + 1);
-    size_t plen = newpathlen;
-    char *p = newpath;
-    size_t res;
-    int err;
-
-    if (!newpath)
-        return -ENOMEM;
-
-    pthread_mutex_lock(&ic->lock);
-    do {
-        res = iconv(fromfs ? ic->fromfs : ic->tofs, (char **) &path, &pathlen,
-                    &p, &plen);
-        if (res == (size_t) -1) {
-            char *tmp;
-            size_t inc;
-
-            err = -EILSEQ;
-            if (errno != E2BIG)
-                goto err;
-
-            inc = (pathlen + 1) * 4;
-            newpathlen += inc;
-            tmp = realloc(newpath, newpathlen + 1);
-            err = -ENOMEM;
-            if (!tmp)
-                goto err;
-
-            p = tmp + (p - newpath);
-            plen += inc;
-            newpath = tmp;
-        }
-    } while (res == (size_t) -1);
-    pthread_mutex_unlock(&ic->lock);
-    *p = '\0';
-    *newpathp = newpath;
-    return 0;
-
- err:
-    iconv(fromfs ? ic->fromfs : ic->tofs, NULL, NULL, NULL, NULL);
-    pthread_mutex_unlock(&ic->lock);
-    free(newpath);
-    return err;
+			  int fromfs)
+{
+	size_t pathlen = strlen(path);
+	size_t newpathlen = pathlen * 4;
+	char *newpath = malloc(newpathlen + 1);
+	size_t plen = newpathlen;
+	char *p = newpath;
+	size_t res;
+	int err;
+
+	if (!newpath)
+		return -ENOMEM;
+
+	pthread_mutex_lock(&ic->lock);
+	do {
+		res = iconv(fromfs ? ic->fromfs : ic->tofs, (char **) &path,
+			    &pathlen, &p, &plen);
+		if (res == (size_t) -1) {
+			char *tmp;
+			size_t inc;
+
+			err = -EILSEQ;
+			if (errno != E2BIG)
+				goto err;
+
+			inc = (pathlen + 1) * 4;
+			newpathlen += inc;
+			tmp = realloc(newpath, newpathlen + 1);
+			err = -ENOMEM;
+			if (!tmp)
+				goto err;
+
+			p = tmp + (p - newpath);
+			plen += inc;
+			newpath = tmp;
+		}
+	} while (res == (size_t) -1);
+	pthread_mutex_unlock(&ic->lock);
+	*p = '\0';
+	*newpathp = newpath;
+	return 0;
+
+err:
+	iconv(fromfs ? ic->fromfs : ic->tofs, NULL, NULL, NULL, NULL);
+	pthread_mutex_unlock(&ic->lock);
+	free(newpath);
+	return err;
 }
 
 static int iconv_getattr(const char *path, struct stat *stbuf)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_getattr(ic->next, newpath, stbuf);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_getattr(ic->next, newpath, stbuf);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_fgetattr(const char *path, struct stat *stbuf,
-                          struct fuse_file_info *fi)
+			  struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_fgetattr(ic->next, newpath, stbuf, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_fgetattr(ic->next, newpath, stbuf, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_access(const char *path, int mask)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_access(ic->next, newpath, mask);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_access(ic->next, newpath, mask);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_readlink(const char *path, char *buf, size_t size)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_readlink(ic->next, newpath, buf, size);
-        if (!err) {
-            char *newlink;
-            err = iconv_convpath(ic, buf, &newlink, 1);
-            if (!err) {
-                strncpy(buf, newlink, size - 1);
-                buf[size - 1] = '\0';
-                free(newlink);
-            }
-        }
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_readlink(ic->next, newpath, buf, size);
+		if (!err) {
+			char *newlink;
+			err = iconv_convpath(ic, buf, &newlink, 1);
+			if (!err) {
+				strncpy(buf, newlink, size - 1);
+				buf[size - 1] = '\0';
+				free(newlink);
+			}
+		}
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_opendir(const char *path, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_opendir(ic->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_opendir(ic->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_dir_fill(void *buf, const char *name,
-                          const struct stat *stbuf, off_t off)
+			  const struct stat *stbuf, off_t off)
 {
-    struct iconv_dh *dh = buf;
-    char *newname;
-    int res = 0;
-    if (iconv_convpath(dh->ic, name, &newname, 1) == 0) {
-        res = dh->prev_filler(dh->prev_buf, newname, stbuf, off);
-        free(newname);
-    }
-    return res;
+	struct iconv_dh *dh = buf;
+	char *newname;
+	int res = 0;
+	if (iconv_convpath(dh->ic, name, &newname, 1) == 0) {
+		res = dh->prev_filler(dh->prev_buf, newname, stbuf, off);
+		free(newname);
+	}
+	return res;
 }
 
 static int iconv_readdir(const char *path, void *buf, fuse_fill_dir_t filler,
-                         off_t offset, struct fuse_file_info *fi)
-{
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        struct iconv_dh dh;
-        dh.ic = ic;
-        dh.prev_buf = buf;
-        dh.prev_filler = filler;
-        err = fuse_fs_readdir(ic->next, newpath, &dh, iconv_dir_fill, offset,
-                              fi);
-        free(newpath);
-    }
-    return err;
+			 off_t offset, struct fuse_file_info *fi)
+{
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		struct iconv_dh dh;
+		dh.ic = ic;
+		dh.prev_buf = buf;
+		dh.prev_filler = filler;
+		err = fuse_fs_readdir(ic->next, newpath, &dh, iconv_dir_fill,
+				      offset, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_releasedir(const char *path, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_releasedir(ic->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_releasedir(ic->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_mknod(const char *path, mode_t mode, dev_t rdev)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_mknod(ic->next, newpath, mode, rdev);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_mknod(ic->next, newpath, mode, rdev);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_mkdir(const char *path, mode_t mode)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_mkdir(ic->next, newpath, mode);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_mkdir(ic->next, newpath, mode);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_unlink(const char *path)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_unlink(ic->next, newpath);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_unlink(ic->next, newpath);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_rmdir(const char *path)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_rmdir(ic->next, newpath);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_rmdir(ic->next, newpath);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_symlink(const char *from, const char *to)
 {
-    struct iconv *ic = iconv_get();
-    char *newfrom;
-    char *newto;
-    int err = iconv_convpath(ic, from, &newfrom, 0);
-    if (!err) {
-        err = iconv_convpath(ic, to, &newto, 0);
-        if (!err) {
-            err = fuse_fs_symlink(ic->next, newfrom, newto);
-            free(newto);
-        }
-        free(newfrom);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newfrom;
+	char *newto;
+	int err = iconv_convpath(ic, from, &newfrom, 0);
+	if (!err) {
+		err = iconv_convpath(ic, to, &newto, 0);
+		if (!err) {
+			err = fuse_fs_symlink(ic->next, newfrom, newto);
+			free(newto);
+		}
+		free(newfrom);
+	}
+	return err;
 }
 
 static int iconv_rename(const char *from, const char *to)
 {
-    struct iconv *ic = iconv_get();
-    char *newfrom;
-    char *newto;
-    int err = iconv_convpath(ic, from, &newfrom, 0);
-    if (!err) {
-        err = iconv_convpath(ic, to, &newto, 0);
-        if (!err) {
-            err = fuse_fs_rename(ic->next, newfrom, newto);
-            free(newto);
-        }
-        free(newfrom);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newfrom;
+	char *newto;
+	int err = iconv_convpath(ic, from, &newfrom, 0);
+	if (!err) {
+		err = iconv_convpath(ic, to, &newto, 0);
+		if (!err) {
+			err = fuse_fs_rename(ic->next, newfrom, newto);
+			free(newto);
+		}
+		free(newfrom);
+	}
+	return err;
 }
 
 static int iconv_link(const char *from, const char *to)
 {
-    struct iconv *ic = iconv_get();
-    char *newfrom;
-    char *newto;
-    int err = iconv_convpath(ic, from, &newfrom, 0);
-    if (!err) {
-        err = iconv_convpath(ic, to, &newto, 0);
-        if (!err) {
-            err = fuse_fs_link(ic->next, newfrom, newto);
-            free(newto);
-        }
-        free(newfrom);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newfrom;
+	char *newto;
+	int err = iconv_convpath(ic, from, &newfrom, 0);
+	if (!err) {
+		err = iconv_convpath(ic, to, &newto, 0);
+		if (!err) {
+			err = fuse_fs_link(ic->next, newfrom, newto);
+			free(newto);
+		}
+		free(newfrom);
+	}
+	return err;
 }
 
 static int iconv_chmod(const char *path, mode_t mode)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_chmod(ic->next, newpath, mode);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_chmod(ic->next, newpath, mode);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_chown(const char *path, uid_t uid, gid_t gid)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_chown(ic->next, newpath, uid, gid);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_chown(ic->next, newpath, uid, gid);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_truncate(const char *path, off_t size)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_truncate(ic->next, newpath, size);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_truncate(ic->next, newpath, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_ftruncate(const char *path, off_t size,
-                           struct fuse_file_info *fi)
+			   struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_ftruncate(ic->next, newpath, size, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_ftruncate(ic->next, newpath, size, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_utimens(const char *path, const struct timespec ts[2])
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_utimens(ic->next, newpath, ts);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_utimens(ic->next, newpath, ts);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_create(const char *path, mode_t mode,
-                        struct fuse_file_info *fi)
+			struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_create(ic->next, newpath, mode, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_create(ic->next, newpath, mode, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_open_file(const char *path, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_open(ic->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_open(ic->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_read(const char *path, char *buf, size_t size, off_t offset,
-                    struct fuse_file_info *fi)
+		      struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_read(ic->next, newpath, buf, size, offset, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_read(ic->next, newpath, buf, size, offset, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_write(const char *path, const char *buf, size_t size,
-                       off_t offset, struct fuse_file_info *fi)
+		       off_t offset, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_write(ic->next, newpath, buf, size, offset, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_write(ic->next, newpath, buf, size, offset, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_statfs(const char *path, struct statvfs *stbuf)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_statfs(ic->next, newpath, stbuf);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_statfs(ic->next, newpath, stbuf);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_flush(const char *path, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_flush(ic->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_flush(ic->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_release(const char *path, struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_release(ic->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_release(ic->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_fsync(const char *path, int isdatasync,
-                       struct fuse_file_info *fi)
+		       struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_fsync(ic->next, newpath, isdatasync, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_fsync(ic->next, newpath, isdatasync, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_fsyncdir(const char *path, int isdatasync,
-                          struct fuse_file_info *fi)
+			  struct fuse_file_info *fi)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_fsyncdir(ic->next, newpath, isdatasync, fi);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_fsyncdir(ic->next, newpath, isdatasync, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_setxattr(const char *path, const char *name,
-                          const char *value, size_t size, int flags)
+			  const char *value, size_t size, int flags)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_setxattr(ic->next, newpath, name, value, size, flags);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_setxattr(ic->next, newpath, name, value, size,
+				       flags);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_getxattr(const char *path, const char *name, char *value,
-                          size_t size)
+			  size_t size)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_getxattr(ic->next, newpath, name, value, size);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_getxattr(ic->next, newpath, name, value, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_listxattr(const char *path, char *list, size_t size)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_listxattr(ic->next, newpath, list, size);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_listxattr(ic->next, newpath, list, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_removexattr(const char *path, const char *name)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_removexattr(ic->next, newpath, name);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_removexattr(ic->next, newpath, name);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_lock(const char *path, struct fuse_file_info *fi, int cmd,
-                      struct flock *lock)
+		      struct flock *lock)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_lock(ic->next, newpath, fi, cmd, lock);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_lock(ic->next, newpath, fi, cmd, lock);
+		free(newpath);
+	}
+	return err;
 }
 
 static int iconv_bmap(const char *path, size_t blocksize, uint64_t *idx)
 {
-    struct iconv *ic = iconv_get();
-    char *newpath;
-    int err = iconv_convpath(ic, path, &newpath, 0);
-    if (!err) {
-        err = fuse_fs_bmap(ic->next, newpath, blocksize, idx);
-        free(newpath);
-    }
-    return err;
+	struct iconv *ic = iconv_get();
+	char *newpath;
+	int err = iconv_convpath(ic, path, &newpath, 0);
+	if (!err) {
+		err = fuse_fs_bmap(ic->next, newpath, blocksize, idx);
+		free(newpath);
+	}
+	return err;
 }
 
 static void *iconv_init(struct fuse_conn_info *conn)
 {
-    struct iconv *ic = iconv_get();
-    fuse_fs_init(ic->next, conn);
-    return ic;
+	struct iconv *ic = iconv_get();
+	fuse_fs_init(ic->next, conn);
+	return ic;
 }
 
 static void iconv_destroy(void *data)
 {
-    struct iconv *ic = data;
-    fuse_fs_destroy(ic->next);
-    iconv_close(ic->tofs);
-    iconv_close(ic->fromfs);
-    pthread_mutex_destroy(&ic->lock);
-    free(ic->from_code);
-    free(ic->to_code);
-    free(ic);
+	struct iconv *ic = data;
+	fuse_fs_destroy(ic->next);
+	iconv_close(ic->tofs);
+	iconv_close(ic->fromfs);
+	pthread_mutex_destroy(&ic->lock);
+	free(ic->from_code);
+	free(ic->to_code);
+	free(ic);
 }
 
 static struct fuse_operations iconv_oper = {
-    .destroy	= iconv_destroy,
-    .init	= iconv_init,
-    .getattr	= iconv_getattr,
-    .fgetattr	= iconv_fgetattr,
-    .access	= iconv_access,
-    .readlink	= iconv_readlink,
-    .opendir	= iconv_opendir,
-    .readdir	= iconv_readdir,
-    .releasedir	= iconv_releasedir,
-    .mknod	= iconv_mknod,
-    .mkdir	= iconv_mkdir,
-    .symlink	= iconv_symlink,
-    .unlink	= iconv_unlink,
-    .rmdir	= iconv_rmdir,
-    .rename	= iconv_rename,
-    .link	= iconv_link,
-    .chmod	= iconv_chmod,
-    .chown	= iconv_chown,
-    .truncate	= iconv_truncate,
-    .ftruncate	= iconv_ftruncate,
-    .utimens	= iconv_utimens,
-    .create	= iconv_create,
-    .open	= iconv_open_file,
-    .read	= iconv_read,
-    .write	= iconv_write,
-    .statfs	= iconv_statfs,
-    .flush	= iconv_flush,
-    .release	= iconv_release,
-    .fsync	= iconv_fsync,
-    .fsyncdir	= iconv_fsyncdir,
-    .setxattr	= iconv_setxattr,
-    .getxattr	= iconv_getxattr,
-    .listxattr	= iconv_listxattr,
-    .removexattr= iconv_removexattr,
-    .lock	= iconv_lock,
-    .bmap	= iconv_bmap,
+	.destroy	= iconv_destroy,
+	.init		= iconv_init,
+	.getattr	= iconv_getattr,
+	.fgetattr	= iconv_fgetattr,
+	.access		= iconv_access,
+	.readlink	= iconv_readlink,
+	.opendir	= iconv_opendir,
+	.readdir	= iconv_readdir,
+	.releasedir	= iconv_releasedir,
+	.mknod		= iconv_mknod,
+	.mkdir		= iconv_mkdir,
+	.symlink	= iconv_symlink,
+	.unlink		= iconv_unlink,
+	.rmdir		= iconv_rmdir,
+	.rename		= iconv_rename,
+	.link		= iconv_link,
+	.chmod		= iconv_chmod,
+	.chown		= iconv_chown,
+	.truncate	= iconv_truncate,
+	.ftruncate	= iconv_ftruncate,
+	.utimens	= iconv_utimens,
+	.create		= iconv_create,
+	.open		= iconv_open_file,
+	.read		= iconv_read,
+	.write		= iconv_write,
+	.statfs		= iconv_statfs,
+	.flush		= iconv_flush,
+	.release	= iconv_release,
+	.fsync		= iconv_fsync,
+	.fsyncdir	= iconv_fsyncdir,
+	.setxattr	= iconv_setxattr,
+	.getxattr	= iconv_getxattr,
+	.listxattr	= iconv_listxattr,
+	.removexattr	= iconv_removexattr,
+	.lock		= iconv_lock,
+	.bmap		= iconv_bmap,
 };
 
 static struct fuse_opt iconv_opts[] = {
-    FUSE_OPT_KEY("-h", 0),
-    FUSE_OPT_KEY("--help", 0),
-    { "from_code=%s", offsetof(struct iconv, from_code), 0 },
-    { "to_code=%s", offsetof(struct iconv, to_code), 1 },
-    FUSE_OPT_END
+	FUSE_OPT_KEY("-h", 0),
+	FUSE_OPT_KEY("--help", 0),
+	{ "from_code=%s", offsetof(struct iconv, from_code), 0 },
+	{ "to_code=%s", offsetof(struct iconv, to_code), 1 },
+	FUSE_OPT_END
 };
 
 static void iconv_help(void)
 {
-    char *old = strdup(setlocale(LC_CTYPE, ""));
-    char *charmap = strdup(nl_langinfo(CODESET));
-    setlocale(LC_CTYPE, old);
-    free(old);
-    fprintf(stderr,
+	char *old = strdup(setlocale(LC_CTYPE, ""));
+	char *charmap = strdup(nl_langinfo(CODESET));
+	setlocale(LC_CTYPE, old);
+	free(old);
+	fprintf(stderr,
 "    -o from_code=CHARSET   original encoding of file names (default: UTF-8)\n"
-"    -o to_code=CHARSET     new encoding of the file names (default: %s)\n",
-            charmap);
-    free(charmap);
+"    -o to_code=CHARSET	    new encoding of the file names (default: %s)\n",
+		charmap);
+	free(charmap);
 }
 
 static int iconv_opt_proc(void *data, const char *arg, int key,
-                           struct fuse_args *outargs)
+			  struct fuse_args *outargs)
 {
-    (void) data; (void) arg; (void) outargs;
+	(void) data; (void) arg; (void) outargs;
 
-    if (!key) {
-        iconv_help();
-        return -1;
-    }
+	if (!key) {
+		iconv_help();
+		return -1;
+	}
 
-    return 1;
+	return 1;
 }
 
 static struct fuse_fs *iconv_new(struct fuse_args *args,
-                                  struct fuse_fs *next[])
-{
-    struct fuse_fs *fs;
-    struct iconv *ic;
-    char *old = NULL;
-    const char *from;
-    const char *to;
-
-    ic = calloc(1, sizeof(struct iconv));
-    if (ic == NULL) {
-        fprintf(stderr, "fuse-iconv: memory allocation failed\n");
-        return NULL;
-    }
-
-    if (fuse_opt_parse(args, ic, iconv_opts, iconv_opt_proc) == -1)
-        goto out_free;
-
-    if (!next[0] || next[1]) {
-        fprintf(stderr, "fuse-iconv: exactly one next filesystem required\n");
-        goto out_free;
-    }
-
-    from = ic->from_code ? ic->from_code : "UTF-8";
-    to = ic->to_code ? ic->to_code : "";
-    /* FIXME: detect charset equivalence? */
-    if (!to[0])
-        old = strdup(setlocale(LC_CTYPE, ""));
-    ic->tofs = iconv_open(from, to);
-    if (ic->tofs == (iconv_t) -1) {
-        fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
-                to, from);
-        goto out_free;
-    }
-    ic->fromfs = iconv_open(to, from);
-    if (ic->tofs == (iconv_t) -1) {
-        fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
-                from, to);
-        goto out_iconv_close_to;
-    }
-    if (old) {
-        setlocale(LC_CTYPE, old);
-        free(old);
-    }
-
-    ic->next = next[0];
-    fs = fuse_fs_new(&iconv_oper, sizeof(iconv_oper), ic);
-    if (!fs)
-        goto out_iconv_close_from;
-
-    return fs;
-
- out_iconv_close_from:
-    iconv_close(ic->fromfs);
- out_iconv_close_to:
-    iconv_close(ic->tofs);
- out_free:
-    free(ic->from_code);
-    free(ic->to_code);
-    free(ic);
-    return NULL;
+				 struct fuse_fs *next[])
+{
+	struct fuse_fs *fs;
+	struct iconv *ic;
+	char *old = NULL;
+	const char *from;
+	const char *to;
+
+	ic = calloc(1, sizeof(struct iconv));
+	if (ic == NULL) {
+		fprintf(stderr, "fuse-iconv: memory allocation failed\n");
+		return NULL;
+	}
+
+	if (fuse_opt_parse(args, ic, iconv_opts, iconv_opt_proc) == -1)
+		goto out_free;
+
+	if (!next[0] || next[1]) {
+		fprintf(stderr, "fuse-iconv: exactly one next filesystem required\n");
+		goto out_free;
+	}
+
+	from = ic->from_code ? ic->from_code : "UTF-8";
+	to = ic->to_code ? ic->to_code : "";
+	/* FIXME: detect charset equivalence? */
+	if (!to[0])
+		old = strdup(setlocale(LC_CTYPE, ""));
+	ic->tofs = iconv_open(from, to);
+	if (ic->tofs == (iconv_t) -1) {
+		fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
+			to, from);
+		goto out_free;
+	}
+	ic->fromfs = iconv_open(to, from);
+	if (ic->tofs == (iconv_t) -1) {
+		fprintf(stderr, "fuse-iconv: cannot convert from %s to %s\n",
+			from, to);
+		goto out_iconv_close_to;
+	}
+	if (old) {
+		setlocale(LC_CTYPE, old);
+		free(old);
+	}
+
+	ic->next = next[0];
+	fs = fuse_fs_new(&iconv_oper, sizeof(iconv_oper), ic);
+	if (!fs)
+		goto out_iconv_close_from;
+
+	return fs;
+
+out_iconv_close_from:
+	iconv_close(ic->fromfs);
+out_iconv_close_to:
+	iconv_close(ic->tofs);
+out_free:
+	free(ic->from_code);
+	free(ic->to_code);
+	free(ic);
+	return NULL;
 }
 
 FUSE_REGISTER_MODULE(iconv, iconv_new);
diff --git a/lib/modules/subdir.c b/lib/modules/subdir.c
index f22c023..6f7b187 100644
--- a/lib/modules/subdir.c
+++ b/lib/modules/subdir.c
@@ -1,9 +1,9 @@
 /*
-    fuse subdir module: offset paths with a base directory
-    Copyright (C) 2007  Miklos Szeredi <miklos@szeredi.hu>
+  fuse subdir module: offset paths with a base directory
+  Copyright (C) 2007  Miklos Szeredi <miklos@szeredi.hu>
 
-    This program can be distributed under the terms of the GNU LGPLv2.
-    See the file COPYING.LIB
+  This program can be distributed under the terms of the GNU LGPLv2.
+  See the file COPYING.LIB
 */
 
 #define FUSE_USE_VERSION 26
@@ -16,647 +16,650 @@
 #include <errno.h>
 
 struct subdir {
-    char *base;
-    size_t baselen;
-    int rellinks;
-    struct fuse_fs *next;
+	char *base;
+	size_t baselen;
+	int rellinks;
+	struct fuse_fs *next;
 };
 
 static struct subdir *subdir_get(void)
 {
-    return fuse_get_context()->private_data;
+	return fuse_get_context()->private_data;
 }
 
 static char *subdir_addpath(struct subdir *d, const char *path)
 {
-    unsigned newlen = d->baselen + strlen(path);
-    char *newpath = malloc(newlen + 2);
-    if (newpath) {
-        if (path[0] == '/')
-            path++;
-        strcpy(newpath, d->base);
-        strcpy(newpath + d->baselen, path);
-        if (!newpath[0])
-            strcpy(newpath, ".");
-    }
-    return newpath;
+	unsigned newlen = d->baselen + strlen(path);
+	char *newpath = malloc(newlen + 2);
+	if (newpath) {
+		if (path[0] == '/')
+			path++;
+		strcpy(newpath, d->base);
+		strcpy(newpath + d->baselen, path);
+		if (!newpath[0])
+			strcpy(newpath, ".");
+	}
+	return newpath;
 }
 
 static int subdir_getattr(const char *path, struct stat *stbuf)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_getattr(d->next, newpath, stbuf);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_getattr(d->next, newpath, stbuf);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_fgetattr(const char *path, struct stat *stbuf,
-                           struct fuse_file_info *fi)
+			   struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_fgetattr(d->next, newpath, stbuf, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_fgetattr(d->next, newpath, stbuf, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_access(const char *path, int mask)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_access(d->next, newpath, mask);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_access(d->next, newpath, mask);
+		free(newpath);
+	}
+	return err;
 }
 
 
 static int count_components(const char *p)
 {
-    int ctr;
+	int ctr;
 
-    for (; *p == '/'; p++);
-    for (ctr = 0; *p; ctr++) {
-        for (; *p && *p != '/'; p++);
-        for (; *p == '/'; p++);
-    }
-    return ctr;
+	for (; *p == '/'; p++);
+	for (ctr = 0; *p; ctr++) {
+		for (; *p && *p != '/'; p++);
+		for (; *p == '/'; p++);
+	}
+	return ctr;
 }
 
 static void strip_common(const char **sp, const char **tp)
 {
-    const char *s = *sp;
-    const char *t = *tp;
-    do {
-        for (; *s == '/'; s++);
-        for (; *t == '/'; t++);
-        *tp = t;
-        *sp = s;
-        for (; *s == *t && *s && *s != '/'; s++, t++);
-    } while ((*s == *t && *s) || (!*s && *t == '/') || (*s == '/' && !*t));
+	const char *s = *sp;
+	const char *t = *tp;
+	do {
+		for (; *s == '/'; s++);
+		for (; *t == '/'; t++);
+		*tp = t;
+		*sp = s;
+		for (; *s == *t && *s && *s != '/'; s++, t++);
+	} while ((*s == *t && *s) || (!*s && *t == '/') || (*s == '/' && !*t));
 }
 
 static void transform_symlink(struct subdir *d, const char *path,
-                              char *buf, size_t size)
+			      char *buf, size_t size)
 {
-    const char *l = buf;
-    size_t llen;
-    char *s;
-    int dotdots;
-    int i;
+	const char *l = buf;
+	size_t llen;
+	char *s;
+	int dotdots;
+	int i;
 
-    if (l[0] != '/' || d->base[0] != '/')
-        return;
+	if (l[0] != '/' || d->base[0] != '/')
+		return;
 
-    strip_common(&l, &path);
-    if (l - buf < (long) d->baselen)
-        return;
+	strip_common(&l, &path);
+	if (l - buf < (long) d->baselen)
+		return;
 
-    dotdots = count_components(path);
-    if (!dotdots)
-        return;
-    dotdots--;
+	dotdots = count_components(path);
+	if (!dotdots)
+		return;
+	dotdots--;
 
-    llen = strlen(l);
-    if (dotdots * 3 + llen + 2 > size)
-        return;
+	llen = strlen(l);
+	if (dotdots * 3 + llen + 2 > size)
+		return;
 
-    s = buf + dotdots * 3;
-    if (llen)
-        memmove(s, l, llen + 1);
-    else if (!dotdots)
-        strcpy(s, ".");
-    else
-        *s = '\0';
+	s = buf + dotdots * 3;
+	if (llen)
+		memmove(s, l, llen + 1);
+	else if (!dotdots)
+		strcpy(s, ".");
+	else
+		*s = '\0';
 
-    for (s = buf, i = 0; i < dotdots; i++, s += 3)
-        memcpy(s, "../", 3);
+	for (s = buf, i = 0; i < dotdots; i++, s += 3)
+		memcpy(s, "../", 3);
 }
 
 
 static int subdir_readlink(const char *path, char *buf, size_t size)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_readlink(d->next, newpath, buf, size);
-        if (!err && d->rellinks)
-            transform_symlink(d, newpath, buf, size);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_readlink(d->next, newpath, buf, size);
+		if (!err && d->rellinks)
+			transform_symlink(d, newpath, buf, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_opendir(const char *path, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_opendir(d->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_opendir(d->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_readdir(const char *path, void *buf,
-                          fuse_fill_dir_t filler, off_t offset,
-                          struct fuse_file_info *fi)
+			  fuse_fill_dir_t filler, off_t offset,
+			  struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_readdir(d->next, newpath, buf, filler, offset, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_readdir(d->next, newpath, buf, filler, offset,
+				      fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_releasedir(const char *path, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_releasedir(d->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_releasedir(d->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_mknod(const char *path, mode_t mode, dev_t rdev)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_mknod(d->next, newpath, mode, rdev);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_mknod(d->next, newpath, mode, rdev);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_mkdir(const char *path, mode_t mode)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_mkdir(d->next, newpath, mode);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_mkdir(d->next, newpath, mode);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_unlink(const char *path)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_unlink(d->next, newpath);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_unlink(d->next, newpath);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_rmdir(const char *path)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_rmdir(d->next, newpath);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_rmdir(d->next, newpath);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_symlink(const char *from, const char *path)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_symlink(d->next, from, newpath);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_symlink(d->next, from, newpath);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_rename(const char *from, const char *to)
 {
-    struct subdir *d = subdir_get();
-    char *newfrom = subdir_addpath(d, from);
-    char *newto = subdir_addpath(d, to);
-    int err = -ENOMEM;
-    if (newfrom && newto)
-        err = fuse_fs_rename(d->next, newfrom, newto);
-    free(newfrom);
-    free(newto);
-    return err;
+	struct subdir *d = subdir_get();
+	char *newfrom = subdir_addpath(d, from);
+	char *newto = subdir_addpath(d, to);
+	int err = -ENOMEM;
+	if (newfrom && newto)
+		err = fuse_fs_rename(d->next, newfrom, newto);
+	free(newfrom);
+	free(newto);
+	return err;
 }
 
 static int subdir_link(const char *from, const char *to)
 {
-    struct subdir *d = subdir_get();
-    char *newfrom = subdir_addpath(d, from);
-    char *newto = subdir_addpath(d, to);
-    int err = -ENOMEM;
-    if (newfrom && newto)
-        err = fuse_fs_link(d->next, newfrom, newto);
-    free(newfrom);
-    free(newto);
-    return err;
+	struct subdir *d = subdir_get();
+	char *newfrom = subdir_addpath(d, from);
+	char *newto = subdir_addpath(d, to);
+	int err = -ENOMEM;
+	if (newfrom && newto)
+		err = fuse_fs_link(d->next, newfrom, newto);
+	free(newfrom);
+	free(newto);
+	return err;
 }
 
 static int subdir_chmod(const char *path, mode_t mode)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_chmod(d->next, newpath, mode);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_chmod(d->next, newpath, mode);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_chown(const char *path, uid_t uid, gid_t gid)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_chown(d->next, newpath, uid, gid);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_chown(d->next, newpath, uid, gid);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_truncate(const char *path, off_t size)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_truncate(d->next, newpath, size);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_truncate(d->next, newpath, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_ftruncate(const char *path, off_t size,
-                         struct fuse_file_info *fi)
+			    struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_ftruncate(d->next, newpath, size, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_ftruncate(d->next, newpath, size, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_utimens(const char *path, const struct timespec ts[2])
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_utimens(d->next, newpath, ts);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_utimens(d->next, newpath, ts);
+		free(newpath);
+	}
+	return err;
 }
 
-static int subdir_create(const char *path, mode_t mode, struct fuse_file_info *fi)
+static int subdir_create(const char *path, mode_t mode,
+			 struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_create(d->next, newpath, mode, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_create(d->next, newpath, mode, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_open(const char *path, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_open(d->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_open(d->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_read(const char *path, char *buf, size_t size, off_t offset,
-                    struct fuse_file_info *fi)
+		       struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_read(d->next, newpath, buf, size, offset, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_read(d->next, newpath, buf, size, offset, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_write(const char *path, const char *buf, size_t size,
-                     off_t offset, struct fuse_file_info *fi)
+			off_t offset, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_write(d->next, newpath, buf, size, offset, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_write(d->next, newpath, buf, size, offset, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_statfs(const char *path, struct statvfs *stbuf)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_statfs(d->next, newpath, stbuf);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_statfs(d->next, newpath, stbuf);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_flush(const char *path, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_flush(d->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_flush(d->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_release(const char *path, struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_release(d->next, newpath, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_release(d->next, newpath, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_fsync(const char *path, int isdatasync,
-                        struct fuse_file_info *fi)
+			struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_fsync(d->next, newpath, isdatasync, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_fsync(d->next, newpath, isdatasync, fi);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_fsyncdir(const char *path, int isdatasync,
-                           struct fuse_file_info *fi)
+			   struct fuse_file_info *fi)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_fsyncdir(d->next, newpath, isdatasync, fi);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_fsyncdir(d->next, newpath, isdatasync, fi);
+		free(newpath);
+	}
+	return err;
 }
 
-static int subdir_setxattr(const char *path, const char *name, const char *value,
-                        size_t size, int flags)
+static int subdir_setxattr(const char *path, const char *name,
+			   const char *value, size_t size, int flags)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_setxattr(d->next, newpath, name, value, size, flags);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_setxattr(d->next, newpath, name, value, size,
+				       flags);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_getxattr(const char *path, const char *name, char *value,
-                    size_t size)
+			   size_t size)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_getxattr(d->next, newpath, name, value, size);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_getxattr(d->next, newpath, name, value, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_listxattr(const char *path, char *list, size_t size)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_listxattr(d->next, newpath, list, size);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_listxattr(d->next, newpath, list, size);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_removexattr(const char *path, const char *name)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_removexattr(d->next, newpath, name);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_removexattr(d->next, newpath, name);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_lock(const char *path, struct fuse_file_info *fi, int cmd,
-                    struct flock *lock)
+		       struct flock *lock)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_lock(d->next, newpath, fi, cmd, lock);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_lock(d->next, newpath, fi, cmd, lock);
+		free(newpath);
+	}
+	return err;
 }
 
 static int subdir_bmap(const char *path, size_t blocksize, uint64_t *idx)
 {
-    struct subdir *d = subdir_get();
-    char *newpath = subdir_addpath(d, path);
-    int err = -ENOMEM;
-    if (newpath) {
-        err = fuse_fs_bmap(d->next, newpath, blocksize, idx);
-        free(newpath);
-    }
-    return err;
+	struct subdir *d = subdir_get();
+	char *newpath = subdir_addpath(d, path);
+	int err = -ENOMEM;
+	if (newpath) {
+		err = fuse_fs_bmap(d->next, newpath, blocksize, idx);
+		free(newpath);
+	}
+	return err;
 }
 
 static void *subdir_init(struct fuse_conn_info *conn)
 {
-    struct subdir *d = subdir_get();
-    fuse_fs_init(d->next, conn);
-    return d;
+	struct subdir *d = subdir_get();
+	fuse_fs_init(d->next, conn);
+	return d;
 }
 
 static void subdir_destroy(void *data)
 {
-    struct subdir *d = data;
-    fuse_fs_destroy(d->next);
-    free(d->base);
-    free(d);
+	struct subdir *d = data;
+	fuse_fs_destroy(d->next);
+	free(d->base);
+	free(d);
 }
 
 static struct fuse_operations subdir_oper = {
-    .destroy	= subdir_destroy,
-    .init	= subdir_init,
-    .getattr	= subdir_getattr,
-    .fgetattr	= subdir_fgetattr,
-    .access	= subdir_access,
-    .readlink	= subdir_readlink,
-    .opendir	= subdir_opendir,
-    .readdir	= subdir_readdir,
-    .releasedir	= subdir_releasedir,
-    .mknod	= subdir_mknod,
-    .mkdir	= subdir_mkdir,
-    .symlink	= subdir_symlink,
-    .unlink	= subdir_unlink,
-    .rmdir	= subdir_rmdir,
-    .rename	= subdir_rename,
-    .link	= subdir_link,
-    .chmod	= subdir_chmod,
-    .chown	= subdir_chown,
-    .truncate	= subdir_truncate,
-    .ftruncate	= subdir_ftruncate,
-    .utimens	= subdir_utimens,
-    .create	= subdir_create,
-    .open	= subdir_open,
-    .read	= subdir_read,
-    .write	= subdir_write,
-    .statfs	= subdir_statfs,
-    .flush	= subdir_flush,
-    .release	= subdir_release,
-    .fsync	= subdir_fsync,
-    .fsyncdir	= subdir_fsyncdir,
-    .setxattr	= subdir_setxattr,
-    .getxattr	= subdir_getxattr,
-    .listxattr	= subdir_listxattr,
-    .removexattr= subdir_removexattr,
-    .lock	= subdir_lock,
-    .bmap	= subdir_bmap,
+	.destroy	= subdir_destroy,
+	.init		= subdir_init,
+	.getattr	= subdir_getattr,
+	.fgetattr	= subdir_fgetattr,
+	.access		= subdir_access,
+	.readlink	= subdir_readlink,
+	.opendir	= subdir_opendir,
+	.readdir	= subdir_readdir,
+	.releasedir	= subdir_releasedir,
+	.mknod		= subdir_mknod,
+	.mkdir		= subdir_mkdir,
+	.symlink	= subdir_symlink,
+	.unlink		= subdir_unlink,
+	.rmdir		= subdir_rmdir,
+	.rename		= subdir_rename,
+	.link		= subdir_link,
+	.chmod		= subdir_chmod,
+	.chown		= subdir_chown,
+	.truncate	= subdir_truncate,
+	.ftruncate	= subdir_ftruncate,
+	.utimens	= subdir_utimens,
+	.create		= subdir_create,
+	.open		= subdir_open,
+	.read		= subdir_read,
+	.write		= subdir_write,
+	.statfs		= subdir_statfs,
+	.flush		= subdir_flush,
+	.release	= subdir_release,
+	.fsync		= subdir_fsync,
+	.fsyncdir	= subdir_fsyncdir,
+	.setxattr	= subdir_setxattr,
+	.getxattr	= subdir_getxattr,
+	.listxattr	= subdir_listxattr,
+	.removexattr	= subdir_removexattr,
+	.lock		= subdir_lock,
+	.bmap		= subdir_bmap,
 };
 
 static struct fuse_opt subdir_opts[] = {
-    FUSE_OPT_KEY("-h", 0),
-    FUSE_OPT_KEY("--help", 0),
-    { "subdir=%s", offsetof(struct subdir, base), 0 },
-    { "rellinks", offsetof(struct subdir, rellinks), 1 },
-    { "norellinks", offsetof(struct subdir, rellinks), 0 },
-    FUSE_OPT_END
+	FUSE_OPT_KEY("-h", 0),
+	FUSE_OPT_KEY("--help", 0),
+	{ "subdir=%s", offsetof(struct subdir, base), 0 },
+	{ "rellinks", offsetof(struct subdir, rellinks), 1 },
+	{ "norellinks", offsetof(struct subdir, rellinks), 0 },
+	FUSE_OPT_END
 };
 
 static void subdir_help(void)
 {
-    fprintf(stderr,
-"    -o subdir=DIR          prepend this directory to all paths (mandatory)\n"
-"    -o [no]rellinks        transform absolute symlinks to relative\n");
+	fprintf(stderr,
+"    -o subdir=DIR	    prepend this directory to all paths (mandatory)\n"
+"    -o [no]rellinks	    transform absolute symlinks to relative\n");
 }
 
 static int subdir_opt_proc(void *data, const char *arg, int key,
-                           struct fuse_args *outargs)
+			   struct fuse_args *outargs)
 {
-    (void) data; (void) arg; (void) outargs;
+	(void) data; (void) arg; (void) outargs;
 
-    if (!key) {
-        subdir_help();
-        return -1;
-    }
+	if (!key) {
+		subdir_help();
+		return -1;
+	}
 
-    return 1;
+	return 1;
 }
 
 static struct fuse_fs *subdir_new(struct fuse_args *args,
-                                  struct fuse_fs *next[])
-{
-    struct fuse_fs *fs;
-    struct subdir *d;
-
-    d = calloc(1, sizeof(struct subdir));
-    if (d == NULL) {
-        fprintf(stderr, "fuse-subdir: memory allocation failed\n");
-        return NULL;
-    }
-
-    if (fuse_opt_parse(args, d, subdir_opts, subdir_opt_proc) == -1)
-        goto out_free;
-
-    if (!next[0] || next[1]) {
-        fprintf(stderr, "fuse-subdir: exactly one next filesystem required\n");
-        goto out_free;
-    }
-
-    if (!d->base) {
-        fprintf(stderr, "fuse-subdir: missing 'subdir' option\n");
-        goto out_free;
-    }
-
-    if (d->base[0] && d->base[strlen(d->base)-1] != '/') {
-        char *tmp = realloc(d->base, strlen(d->base) + 2);
-        if (!tmp) {
-            fprintf(stderr, "fuse-subdir: memory allocation failed\n");
-            goto out_free;
-        }
-        d->base = tmp;
-        strcat(d->base, "/");
-    }
-    d->baselen = strlen(d->base);
-    d->next = next[0];
-    fs = fuse_fs_new(&subdir_oper, sizeof(subdir_oper), d);
-    if (!fs)
-        goto out_free;
-    return fs;
-
- out_free:
-    free(d->base);
-    free(d);
-    return NULL;
+				  struct fuse_fs *next[])
+{
+	struct fuse_fs *fs;
+	struct subdir *d;
+
+	d = calloc(1, sizeof(struct subdir));
+	if (d == NULL) {
+		fprintf(stderr, "fuse-subdir: memory allocation failed\n");
+		return NULL;
+	}
+
+	if (fuse_opt_parse(args, d, subdir_opts, subdir_opt_proc) == -1)
+		goto out_free;
+
+	if (!next[0] || next[1]) {
+		fprintf(stderr, "fuse-subdir: exactly one next filesystem required\n");
+		goto out_free;
+	}
+
+	if (!d->base) {
+		fprintf(stderr, "fuse-subdir: missing 'subdir' option\n");
+		goto out_free;
+	}
+
+	if (d->base[0] && d->base[strlen(d->base)-1] != '/') {
+		char *tmp = realloc(d->base, strlen(d->base) + 2);
+		if (!tmp) {
+			fprintf(stderr, "fuse-subdir: memory allocation failed\n");
+			goto out_free;
+		}
+		d->base = tmp;
+		strcat(d->base, "/");
+	}
+	d->baselen = strlen(d->base);
+	d->next = next[0];
+	fs = fuse_fs_new(&subdir_oper, sizeof(subdir_oper), d);
+	if (!fs)
+		goto out_free;
+	return fs;
+
+out_free:
+	free(d->base);
+	free(d);
+	return NULL;
 }
 
 FUSE_REGISTER_MODULE(subdir, subdir_new);