3 * FUSE-based exFAT implementation. Requires FUSE 2.6 or later.
5 * Created by Andrew Nayenko on 01.09.09.
6 * This software is distributed under the GNU General Public License
7 * version 3 or any later.
18 #define exfat_debug(format, ...)
20 #if !defined(FUSE_VERSION) || (FUSE_VERSION < 26)
21 #error FUSE 2.6 or later is required
26 static struct exfat_node* get_node(const struct fuse_file_info* fi)
28 return (struct exfat_node*) (size_t) fi->fh;
31 static void set_node(struct fuse_file_info* fi, struct exfat_node* node)
33 fi->fh = (uint64_t) (size_t) node;
36 static int fuse_exfat_getattr(const char* path, struct stat* stbuf)
38 struct exfat_node* node;
41 exfat_debug("[fuse_exfat_getattr] %s", path);
43 rc = exfat_lookup(&ef, &node, path);
47 exfat_stat(&ef, node, stbuf);
48 exfat_put_node(&ef, node);
52 static int fuse_exfat_truncate(const char* path, off_t size)
54 struct exfat_node* node;
57 exfat_debug("[fuse_exfat_truncate] %s, %llu", path, size);
59 rc = exfat_lookup(&ef, &node, path);
63 exfat_truncate(&ef, node, size);
64 exfat_put_node(&ef, node);
68 static int fuse_exfat_readdir(const char* path, void* buffer,
69 fuse_fill_dir_t filler, off_t offset, struct fuse_file_info* fi)
71 struct exfat_node* parent;
72 struct exfat_node* node;
73 struct exfat_iterator it;
75 char name[EXFAT_NAME_MAX + 1];
77 exfat_debug("[fuse_exfat_readdir] %s", path);
79 rc = exfat_lookup(&ef, &parent, path);
82 if (!(parent->flags & EXFAT_ATTRIB_DIR))
84 exfat_put_node(&ef, parent);
85 exfat_error("`%s' is not a directory (0x%x)", path, parent->flags);
89 filler(buffer, ".", NULL, 0);
90 filler(buffer, "..", NULL, 0);
92 rc = exfat_opendir(&ef, parent, &it);
95 exfat_put_node(&ef, parent);
96 exfat_error("failed to open directory `%s'", path);
99 while ((node = exfat_readdir(&ef, &it)))
101 exfat_get_name(node, name, EXFAT_NAME_MAX);
102 exfat_debug("[fuse_exfat_readdir] %s: %s, %llu bytes, cluster %u",
103 name, IS_CONTIGUOUS(*node) ? "contiguous" : "fragmented",
104 node->size, node->start_cluster);
105 filler(buffer, name, NULL, 0);
106 exfat_put_node(&ef, node);
108 exfat_closedir(&ef, &it);
109 exfat_put_node(&ef, parent);
113 static int fuse_exfat_open(const char* path, struct fuse_file_info* fi)
115 struct exfat_node* node;
118 exfat_debug("[fuse_exfat_open] %s", path);
120 rc = exfat_lookup(&ef, &node, path);
127 static int fuse_exfat_release(const char* path, struct fuse_file_info* fi)
129 exfat_put_node(&ef, get_node(fi));
133 static int fuse_exfat_read(const char* path, char* buffer, size_t size,
134 off_t offset, struct fuse_file_info* fi)
136 exfat_debug("[fuse_exfat_read] %s (%zu bytes)", path, size);
137 return exfat_read(&ef, get_node(fi), buffer, size, offset);
140 static int fuse_exfat_write(const char* path, const char* buffer, size_t size,
141 off_t offset, struct fuse_file_info* fi)
143 exfat_debug("[fuse_exfat_write] %s (%zu bytes)", path, size);
144 return exfat_write(&ef, get_node(fi), buffer, size, offset);
147 static int fuse_exfat_unlink(const char* path)
149 struct exfat_node* node;
152 exfat_debug("[fuse_exfat_unlink] %s", path);
154 rc = exfat_lookup(&ef, &node, path);
158 rc = exfat_unlink(&ef, node);
159 exfat_put_node(&ef, node);
163 static int fuse_exfat_rmdir(const char* path)
165 struct exfat_node* node;
168 exfat_debug("[fuse_exfat_rmdir] %s", path);
170 rc = exfat_lookup(&ef, &node, path);
174 rc = exfat_rmdir(&ef, node);
175 exfat_put_node(&ef, node);
179 static int fuse_exfat_mknod(const char* path, mode_t mode, dev_t dev)
181 exfat_debug("[fuse_exfat_mknod] %s", path);
182 return exfat_mknod(&ef, path);
185 static int fuse_exfat_mkdir(const char* path, mode_t mode)
187 exfat_debug("[fuse_exfat_mkdir] %s", path);
188 return exfat_mkdir(&ef, path);
191 static int fuse_exfat_utimens(const char* path, const struct timespec tv[2])
193 struct exfat_node* node;
196 exfat_debug("[fuse_exfat_utimens] %s", path);
198 rc = exfat_lookup(&ef, &node, path);
202 exfat_utimes(node, tv);
203 exfat_put_node(&ef, node);
207 static int fuse_exfat_statfs(const char* path, struct statvfs* sfs)
209 const uint64_t block_count = le64_to_cpu(ef.sb->block_count);
211 sfs->f_bsize = BLOCK_SIZE(*ef.sb);
212 sfs->f_frsize = CLUSTER_SIZE(*ef.sb);
213 sfs->f_blocks = block_count;
214 sfs->f_bavail = block_count - ef.sb->allocated_percent * block_count / 100;
215 sfs->f_bfree = sfs->f_bavail;
216 sfs->f_namemax = EXFAT_NAME_MAX;
219 Below are fake values because in exFAT there is
220 a) no simple way to count files;
221 b) no such thing as inode;
222 So here we assume that inode = cluster.
224 sfs->f_files = (sfs->f_blocks - sfs->f_bfree) >> ef.sb->bpc_bits;
225 sfs->f_favail = sfs->f_bfree >> ef.sb->bpc_bits;
226 sfs->f_ffree = sfs->f_bavail;
231 static void fuse_exfat_destroy(void* unused)
236 static void usage(const char* prog)
238 fprintf(stderr, "Usage: %s <spec> <mountpoint> [-o options]\n", prog);
242 static struct fuse_operations fuse_exfat_ops =
244 .getattr = fuse_exfat_getattr,
245 .truncate = fuse_exfat_truncate,
246 .readdir = fuse_exfat_readdir,
247 .open = fuse_exfat_open,
248 .release = fuse_exfat_release,
249 .read = fuse_exfat_read,
250 .write = fuse_exfat_write,
251 .unlink = fuse_exfat_unlink,
252 .rmdir = fuse_exfat_rmdir,
253 .mknod = fuse_exfat_mknod,
254 .mkdir = fuse_exfat_mkdir,
255 .utimens = fuse_exfat_utimens,
256 .statfs = fuse_exfat_statfs,
257 .destroy = fuse_exfat_destroy,
260 int main(int argc, char* argv[])
262 struct fuse_args mount_args = FUSE_ARGS_INIT(0, NULL);
263 struct fuse_args newfs_args = FUSE_ARGS_INIT(0, NULL);
264 const char* spec = NULL;
265 const char* mount_point = NULL;
266 const char* mount_options = "";
268 struct fuse_chan* fc = NULL;
269 struct fuse* fh = NULL;
272 printf("FUSE exfat %u.%u\n", EXFAT_VERSION_MAJOR, EXFAT_VERSION_MINOR);
274 for (pp = argv + 1; *pp; pp++)
276 if (strcmp(*pp, "-o") == 0)
283 else if (strcmp(*pp, "-d") == 0)
285 else if (spec == NULL)
287 else if (mount_point == NULL)
292 if (spec == NULL || mount_point == NULL)
295 /* create arguments for fuse_mount() */
296 if (fuse_opt_add_arg(&mount_args, "exfat") != 0 ||
297 fuse_opt_add_arg(&mount_args, "-o") != 0 ||
298 fuse_opt_add_arg(&mount_args, mount_options) != 0)
301 /* create FUSE mount point */
302 fc = fuse_mount(mount_point, &mount_args);
303 fuse_opt_free_args(&mount_args);
307 /* create arguments for fuse_new() */
308 if (fuse_opt_add_arg(&newfs_args, "") != 0 ||
309 (debug && fuse_opt_add_arg(&newfs_args, "-d") != 0))
311 fuse_unmount(mount_point, fc);
315 /* create new FUSE file system */
316 fh = fuse_new(fc, &newfs_args, &fuse_exfat_ops,
317 sizeof(struct fuse_operations), NULL);
318 fuse_opt_free_args(&newfs_args);
321 fuse_unmount(mount_point, fc);
325 /* exit session on HUP, TERM and INT signals and ignore PIPE signal */
326 if (fuse_set_signal_handlers(fuse_get_session(fh)))
328 fuse_unmount(mount_point, fc);
333 if (exfat_mount(&ef, spec, mount_options) != 0)
335 fuse_unmount(mount_point, fc);
340 /* go to background unless "-d" option is passed */
341 fuse_daemonize(debug);
346 /* it's quite illogical but fuse_unmount() must be called BEFORE
348 fuse_unmount(mount_point, fc);