libfuse: fuse-3.18.1/lib/helper.c Source File

libfuse

helper.c
1/*
2 FUSE: Filesystem in Userspace
3 Copyright (C) 2001-2007 Miklos Szeredi <miklos@szeredi.hu>
4
5 Helper functions to create (simple) standalone programs. With the
6 aid of these functions it should be possible to create full FUSE
7 file system by implementing nothing but the request handlers.
8
9 This program can be distributed under the terms of the GNU LGPLv2.
10 See the file LGPL2.txt.
11*/
12
13#include "fuse_config.h"
14#include "fuse_i.h"
15#include "fuse_misc.h"
16#include "fuse_opt.h"
17#include "fuse_lowlevel.h"
18#include "mount_util.h"
19
20#include <stdio.h>
21#include <stdlib.h>
22#include <stddef.h>
23#include <unistd.h>
24#include <string.h>
25#include <limits.h>
26#include <errno.h>
27#include <sys/param.h>
28
29#define FUSE_HELPER_OPT(t, p) \
30 { t, offsetof(struct fuse_cmdline_opts, p), 1 }
31
32static const struct fuse_opt fuse_helper_opts[] = {
33 FUSE_HELPER_OPT("-h", show_help),
34 FUSE_HELPER_OPT("--help", show_help),
35 FUSE_HELPER_OPT("-V", show_version),
36 FUSE_HELPER_OPT("--version", show_version),
37 FUSE_HELPER_OPT("-d", debug),
38 FUSE_HELPER_OPT("debug", debug),
39 FUSE_HELPER_OPT("-d", foreground),
40 FUSE_HELPER_OPT("debug", foreground),
41 FUSE_OPT_KEY("-d", FUSE_OPT_KEY_KEEP),
42 FUSE_OPT_KEY("debug", FUSE_OPT_KEY_KEEP),
43 FUSE_HELPER_OPT("-f", foreground),
44 FUSE_HELPER_OPT("-s", singlethread),
45 FUSE_HELPER_OPT("fsname=", nodefault_subtype),
46 FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP),
47#ifndef __FreeBSD__
48 FUSE_HELPER_OPT("subtype=", nodefault_subtype),
49 FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP),
50#endif
51 FUSE_HELPER_OPT("clone_fd", clone_fd),
52 FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads),
53 FUSE_HELPER_OPT("max_threads=%u", max_threads),
54 FUSE_OPT_END
55};
56
57struct fuse_conn_info_opts {
58 int atomic_o_trunc;
59 int no_remote_posix_lock;
60 int no_remote_flock;
61 int splice_write;
62 int splice_move;
63 int splice_read;
64 int no_splice_write;
65 int no_splice_move;
66 int no_splice_read;
67 int auto_inval_data;
68 int no_auto_inval_data;
69 int no_readdirplus;
70 int no_readdirplus_auto;
71 int async_dio;
72 int no_async_dio;
73 int writeback_cache;
74 int no_writeback_cache;
75 int async_read;
76 int sync_read;
77 unsigned max_write;
78 unsigned max_readahead;
79 unsigned max_background;
80 unsigned congestion_threshold;
81 unsigned time_gran;
82 int set_max_write;
83 int set_max_readahead;
84 int set_max_background;
85 int set_congestion_threshold;
86 int set_time_gran;
87};
88
89#define CONN_OPTION(t, p, v) \
90 { t, offsetof(struct fuse_conn_info_opts, p), v }
91static const struct fuse_opt conn_info_opt_spec[] = {
92 CONN_OPTION("max_write=%u", max_write, 0),
93 CONN_OPTION("max_write=", set_max_write, 1),
94 CONN_OPTION("max_readahead=%u", max_readahead, 0),
95 CONN_OPTION("max_readahead=", set_max_readahead, 1),
96 CONN_OPTION("max_background=%u", max_background, 0),
97 CONN_OPTION("max_background=", set_max_background, 1),
98 CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0),
99 CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1),
100 CONN_OPTION("sync_read", sync_read, 1),
101 CONN_OPTION("async_read", async_read, 1),
102 CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1),
103 CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1),
104 CONN_OPTION("no_remote_lock", no_remote_flock, 1),
105 CONN_OPTION("no_remote_flock", no_remote_flock, 1),
106 CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1),
107 CONN_OPTION("splice_write", splice_write, 1),
108 CONN_OPTION("no_splice_write", no_splice_write, 1),
109 CONN_OPTION("splice_move", splice_move, 1),
110 CONN_OPTION("no_splice_move", no_splice_move, 1),
111 CONN_OPTION("splice_read", splice_read, 1),
112 CONN_OPTION("no_splice_read", no_splice_read, 1),
113 CONN_OPTION("auto_inval_data", auto_inval_data, 1),
114 CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1),
115 CONN_OPTION("readdirplus=no", no_readdirplus, 1),
116 CONN_OPTION("readdirplus=yes", no_readdirplus, 0),
117 CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1),
118 CONN_OPTION("readdirplus=auto", no_readdirplus, 0),
119 CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0),
120 CONN_OPTION("async_dio", async_dio, 1),
121 CONN_OPTION("no_async_dio", no_async_dio, 1),
122 CONN_OPTION("writeback_cache", writeback_cache, 1),
123 CONN_OPTION("no_writeback_cache", no_writeback_cache, 1),
124 CONN_OPTION("time_gran=%u", time_gran, 0),
125 CONN_OPTION("time_gran=", set_time_gran, 1),
126 FUSE_OPT_END
127};
128
129
130void fuse_cmdline_help(void)
131{
132 printf(" -h --help print help\n"
133 " -V --version print version\n"
134 " -d -o debug enable debug output (implies -f)\n"
135 " -f foreground operation\n"
136 " -s disable multi-threaded operation\n"
137 " -o clone_fd use separate fuse device fd for each thread\n"
138 " (may improve performance)\n"
139 " -o max_idle_threads the maximum number of idle worker threads\n"
140 " allowed (default: -1)\n"
141 " -o max_threads the maximum number of worker threads\n"
142 " allowed (default: 10)\n");
143}
144
145static int fuse_helper_opt_proc(void *data, const char *arg, int key,
146 struct fuse_args *outargs)
147{
148 (void) outargs;
149 struct fuse_cmdline_opts *opts = data;
150
151 switch (key) {
152 case FUSE_OPT_KEY_NONOPT:
153 if (!opts->mountpoint) {
154 if (fuse_mnt_parse_fuse_fd(arg) != -1) {
155 return fuse_opt_add_opt(&opts->mountpoint, arg);
156 }
157
158 char mountpoint[PATH_MAX] = "";
159 if (realpath(arg, mountpoint) == NULL) {
160 fuse_log(FUSE_LOG_ERR,
161 "fuse: bad mount point `%s': %s\n",
162 arg, strerror(errno));
163 return -1;
164 }
165 return fuse_opt_add_opt(&opts->mountpoint, mountpoint);
166 } else {
167 fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg);
168 return -1;
169 }
170
171 default:
172 /* Pass through unknown options */
173 return 1;
174 }
175}
176
177/* Under FreeBSD, there is no subtype option so this
178 function actually sets the fsname */
179static int add_default_subtype(const char *progname, struct fuse_args *args)
180{
181 int res;
182 char *subtype_opt;
183
184 const char *basename = strrchr(progname, '/');
185 if (basename == NULL)
186 basename = progname;
187 else if (basename[1] != '\0')
188 basename++;
189
190 subtype_opt = (char *) malloc(strlen(basename) + 64);
191 if (subtype_opt == NULL) {
192 fuse_log(FUSE_LOG_ERR, "fuse: memory allocation failed\n");
193 return -1;
194 }
195#ifdef __FreeBSD__
196 sprintf(subtype_opt, "-ofsname=%s", basename);
197#else
198 sprintf(subtype_opt, "-osubtype=%s", basename);
199#endif
200 res = fuse_opt_add_arg(args, subtype_opt);
201 free(subtype_opt);
202 return res;
203}
204
205int fuse_parse_cmdline_312(struct fuse_args *args,
206 struct fuse_cmdline_opts *opts);
207FUSE_SYMVER("fuse_parse_cmdline_312", "fuse_parse_cmdline@@FUSE_3.12")
208int fuse_parse_cmdline_312(struct fuse_args *args,
209 struct fuse_cmdline_opts *opts)
210{
211 memset(opts, 0, sizeof(struct fuse_cmdline_opts));
212
213 opts->max_idle_threads = UINT_MAX; /* new default in fuse version 3.12 */
214 opts->max_threads = 10;
215
216 if (fuse_opt_parse(args, opts, fuse_helper_opts,
217 fuse_helper_opt_proc) == -1)
218 return -1;
219
220 /* *Linux*: if neither -o subtype nor -o fsname are specified,
221 set subtype to program's basename.
222 *FreeBSD*: if fsname is not specified, set to program's
223 basename. */
224 if (!opts->nodefault_subtype)
225 if (add_default_subtype(args->argv[0], args) == -1)
226 return -1;
227
228 return 0;
229}
230
234int fuse_parse_cmdline_30(struct fuse_args *args,
235 struct fuse_cmdline_opts *opts);
236FUSE_SYMVER("fuse_parse_cmdline_30", "fuse_parse_cmdline@FUSE_3.0")
237int fuse_parse_cmdline_30(struct fuse_args *args,
238 struct fuse_cmdline_opts *out_opts)
239{
240 struct fuse_cmdline_opts opts;
241
242 int rc = fuse_parse_cmdline_312(args, &opts);
243 if (rc == 0) {
244 /* copy up to the size of the old pre 3.12 struct */
245 memcpy(out_opts, &opts,
246 offsetof(struct fuse_cmdline_opts, max_idle_threads) +
247 sizeof(opts.max_idle_threads));
248 }
249
250 return rc;
251}
252
253int fuse_daemonize(int foreground)
254{
255 if (!foreground) {
256 int nullfd;
257 int waiter[2];
258 char completed;
259
260 if (pipe(waiter)) {
261 perror("fuse_daemonize: pipe");
262 return -1;
263 }
264
265 /*
266 * demonize current process by forking it and killing the
267 * parent. This makes current process as a child of 'init'.
268 */
269 switch(fork()) {
270 case -1:
271 perror("fuse_daemonize: fork");
272 return -1;
273 case 0:
274 break;
275 default:
276 (void) read(waiter[0], &completed, sizeof(completed));
277 _exit(0);
278 }
279
280 if (setsid() == -1) {
281 perror("fuse_daemonize: setsid");
282 return -1;
283 }
284
285 (void) chdir("/");
286
287 nullfd = open("/dev/null", O_RDWR, 0);
288 if (nullfd != -1) {
289 (void) dup2(nullfd, 0);
290 (void) dup2(nullfd, 1);
291 (void) dup2(nullfd, 2);
292 if (nullfd > 2)
293 close(nullfd);
294 }
295
296 /* Propagate completion of daemon initialization */
297 completed = 1;
298 (void) write(waiter[1], &completed, sizeof(completed));
299 close(waiter[0]);
300 close(waiter[1]);
301 } else {
302 (void) chdir("/");
303 }
304 return 0;
305}
306
307int fuse_main_real_versioned(int argc, char *argv[],
308 const struct fuse_operations *op, size_t op_size,
309 struct libfuse_version *version, void *user_data)
310{
311 struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
312 struct fuse *fuse;
313 struct fuse_cmdline_opts opts;
314 int res;
315 struct fuse_loop_config *loop_config = NULL;
316
317 if (fuse_parse_cmdline(&args, &opts) != 0)
318 return 1;
319
320 if (opts.show_version) {
321 printf("FUSE library version %s\n", PACKAGE_VERSION);
322 fuse_lowlevel_version();
323 res = 0;
324 goto out1;
325 }
326
327 if (opts.show_help) {
328 if(args.argv[0][0] != '\0')
329 printf("usage: %s [options] <mountpoint>\n\n",
330 args.argv[0]);
331 printf("FUSE options:\n");
332 fuse_cmdline_help();
333 fuse_lib_help(&args);
334 res = 0;
335 goto out1;
336 }
337
338 if (!opts.show_help &&
339 !opts.mountpoint) {
340 fuse_log(FUSE_LOG_ERR, "error: no mountpoint specified\n");
341 res = 2;
342 goto out1;
343 }
344
345 struct fuse *_fuse_new_31(struct fuse_args *args,
346 const struct fuse_operations *op, size_t op_size,
347 struct libfuse_version *version,
348 void *user_data);
349 fuse = _fuse_new_31(&args, op, op_size, version, user_data);
350 if (fuse == NULL) {
351 res = 3;
352 goto out1;
353 }
354
355 if (fuse_mount(fuse,opts.mountpoint) != 0) {
356 res = 4;
357 goto out2;
358 }
359
360 if (fuse_daemonize(opts.foreground) != 0) {
361 res = 5;
362 goto out3;
363 }
364
365 struct fuse_session *se = fuse_get_session(fuse);
366 if (fuse_set_signal_handlers(se) != 0) {
367 res = 6;
368 goto out3;
369 }
370
371 if (opts.singlethread)
372 res = fuse_loop(fuse);
373 else {
374 loop_config = fuse_loop_cfg_create();
375 if (loop_config == NULL) {
376 res = 7;
377 goto out3;
378 }
379
380 fuse_loop_cfg_set_clone_fd(loop_config, opts.clone_fd);
381
382 fuse_loop_cfg_set_idle_threads(loop_config, opts.max_idle_threads);
383 fuse_loop_cfg_set_max_threads(loop_config, opts.max_threads);
384 res = fuse_loop_mt(fuse, loop_config);
385 }
386 if (res)
387 res = 8;
388
389 fuse_remove_signal_handlers(se);
390out3:
391 fuse_unmount(fuse);
392out2:
393 fuse_destroy(fuse);
394out1:
395 fuse_loop_cfg_destroy(loop_config);
396 free(opts.mountpoint);
397 fuse_opt_free_args(&args);
398 return res;
399}
400
401/* Not symboled, as not part of the official API */
402int fuse_main_real_30(int argc, char *argv[], const struct fuse_operations *op,
403 size_t op_size, void *user_data);
404int fuse_main_real_30(int argc, char *argv[], const struct fuse_operations *op,
405 size_t op_size, void *user_data)
406{
407 struct libfuse_version version = { 0 };
408 return fuse_main_real_versioned(argc, argv, op, op_size, &version,
409 user_data);
410}
411
412void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts,
413 struct fuse_conn_info *conn)
414{
415 if(opts->set_max_write)
416 conn->max_write = opts->max_write;
417 if(opts->set_max_background)
418 conn->max_background = opts->max_background;
419 if(opts->set_congestion_threshold)
420 conn->congestion_threshold = opts->congestion_threshold;
421 if(opts->set_time_gran)
422 conn->time_gran = opts->time_gran;
423 if(opts->set_max_readahead)
424 conn->max_readahead = opts->max_readahead;
425
426#define LL_ENABLE(cond, cap) \
427 do { \
428 if (cond) \
429 fuse_set_feature_flag(conn, cap); \
430 } while (0)
431
432#define LL_DISABLE(cond, cap) \
433 do { \
434 if (cond) \
435 fuse_unset_feature_flag(conn, cap); \
436 } while (0)
437
438 LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ);
439 LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ);
440
441 LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE);
442 LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE);
443
444 LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE);
445 LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE);
446
447 LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
448 LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA);
449
450 LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS);
451 LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO);
452
453 LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO);
454 LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO);
455
456 LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
457 LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE);
458
459 LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ);
460 LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ);
461
462 LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS);
463 LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS);
464}
465
466struct fuse_conn_info_opts* fuse_parse_conn_info_opts(struct fuse_args *args)
467{
468 struct fuse_conn_info_opts *opts;
469
470 opts = calloc(1, sizeof(struct fuse_conn_info_opts));
471 if(opts == NULL) {
472 fuse_log(FUSE_LOG_ERR, "calloc failed\n");
473 return NULL;
474 }
475 if(fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) {
476 free(opts);
477 return NULL;
478 }
479 return opts;
480}
481
482int fuse_open_channel(const char *mountpoint, const char* options)
483{
484 struct mount_opts *opts = NULL;
485 int fd = -1;
486 const char *argv[] = { "", "-o", options };
487 int argc = sizeof(argv) / sizeof(argv[0]);
488 struct fuse_args args = FUSE_ARGS_INIT(argc, (char**) argv);
489
490 opts = parse_mount_opts(&args);
491 if (opts == NULL)
492 return -1;
493
494 fd = fuse_kern_mount(mountpoint, opts);
495 destroy_mount_opts(opts);
496
497 return fd;
498}
fuse_mount
int fuse_mount(struct fuse *f, const char *mountpoint)
Definition fuse.c:5197
fuse_destroy
void fuse_destroy(struct fuse *f)
Definition fuse.c:5146
fuse_main_real_versioned
int fuse_main_real_versioned(int argc, char *argv[], const struct fuse_operations *op, size_t op_size, struct libfuse_version *version, void *user_data)
Definition helper.c:307
fuse_loop
int fuse_loop(struct fuse *f)
Definition fuse.c:4577
fuse_lib_help
void fuse_lib_help(struct fuse_args *args)
Definition fuse.c:4744
fuse_open_channel
int fuse_open_channel(const char *mountpoint, const char *options)
Definition helper.c:482
fuse_get_session
struct fuse_session * fuse_get_session(struct fuse *f)
Definition fuse.c:4520
fuse_unmount
void fuse_unmount(struct fuse *f)
Definition fuse.c:5202
FUSE_CAP_AUTO_INVAL_DATA
#define FUSE_CAP_AUTO_INVAL_DATA
Definition fuse_common.h:281
fuse_set_signal_handlers
int fuse_set_signal_handlers(struct fuse_session *se)
Definition fuse_signals.c:140
FUSE_CAP_SPLICE_READ
#define FUSE_CAP_SPLICE_READ
Definition fuse_common.h:239
FUSE_CAP_WRITEBACK_CACHE
#define FUSE_CAP_WRITEBACK_CACHE
Definition fuse_common.h:337
FUSE_CAP_ASYNC_READ
#define FUSE_CAP_ASYNC_READ
Definition fuse_common.h:177
FUSE_CAP_SPLICE_WRITE
#define FUSE_CAP_SPLICE_WRITE
Definition fuse_common.h:222
FUSE_CAP_POSIX_LOCKS
#define FUSE_CAP_POSIX_LOCKS
Definition fuse_common.h:185
FUSE_CAP_READDIRPLUS_AUTO
#define FUSE_CAP_READDIRPLUS_AUTO
Definition fuse_common.h:317
fuse_parse_conn_info_opts
struct fuse_conn_info_opts * fuse_parse_conn_info_opts(struct fuse_args *args)
Definition helper.c:466
FUSE_CAP_ASYNC_DIO
#define FUSE_CAP_ASYNC_DIO
Definition fuse_common.h:328
FUSE_CAP_READDIRPLUS
#define FUSE_CAP_READDIRPLUS
Definition fuse_common.h:289
fuse_remove_signal_handlers
void fuse_remove_signal_handlers(struct fuse_session *se)
Definition fuse_signals.c:187
FUSE_CAP_SPLICE_MOVE
#define FUSE_CAP_SPLICE_MOVE
Definition fuse_common.h:230
fuse_daemonize
int fuse_daemonize(int foreground)
Definition helper.c:253
FUSE_CAP_FLOCK_LOCKS
#define FUSE_CAP_FLOCK_LOCKS
Definition fuse_common.h:252
fuse_log
void fuse_log(enum fuse_log_level level, const char *fmt,...)
Definition fuse_log.c:77
fuse_cmdline_help
void fuse_cmdline_help(void)
Definition helper.c:130
fuse_lowlevel_version
void fuse_lowlevel_version(void)
Definition fuse_lowlevel.c:2993
fuse_opt_add_arg
int fuse_opt_add_arg(struct fuse_args *args, const char *arg)
Definition fuse_opt.c:55
fuse_opt_free_args
void fuse_opt_free_args(struct fuse_args *args)
Definition fuse_opt.c:34
FUSE_OPT_KEY
#define FUSE_OPT_KEY(templ, key)
Definition fuse_opt.h:98
fuse_opt_parse
int fuse_opt_parse(struct fuse_args *args, void *data, const struct fuse_opt opts[], fuse_opt_proc_t proc)
Definition fuse_opt.c:398
FUSE_OPT_KEY_NONOPT
#define FUSE_OPT_KEY_NONOPT
Definition fuse_opt.h:137
FUSE_OPT_KEY_KEEP
#define FUSE_OPT_KEY_KEEP
Definition fuse_opt.h:145
FUSE_ARGS_INIT
#define FUSE_ARGS_INIT(argc, argv)
Definition fuse_opt.h:123
fuse_opt_add_opt
int fuse_opt_add_opt(char **opts, const char *opt)
Definition fuse_opt.c:139
FUSE_OPT_END
#define FUSE_OPT_END
Definition fuse_opt.h:104
fuse_apply_conn_info_opts
void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts, struct fuse_conn_info *conn)
Definition helper.c:412
fuse_parse_cmdline_30
int fuse_parse_cmdline_30(struct fuse_args *args, struct fuse_cmdline_opts *opts)
Definition helper.c:237
fuse_args
Definition fuse_opt.h:109
fuse_args::argc
int argc
Definition fuse_opt.h:111
fuse_args::argv
char ** argv
Definition fuse_opt.h:114
fuse_cmdline_opts
Definition fuse_lowlevel.h:2003
fuse_conn_info
Definition fuse_common.h:538
fuse_conn_info::time_gran
uint32_t time_gran
Definition fuse_common.h:647
fuse_conn_info::congestion_threshold
uint32_t congestion_threshold
Definition fuse_common.h:630
fuse_conn_info::max_write
uint32_t max_write
Definition fuse_common.h:552
fuse_conn_info::max_readahead
uint32_t max_readahead
Definition fuse_common.h:571
fuse_conn_info::max_background
uint32_t max_background
Definition fuse_common.h:620
fuse_loop_config
Definition fuse_common.h:139
fuse_operations
Definition fuse.h:349
fuse_opt
Definition fuse_opt.h:77
libfuse_version
Definition fuse_common.h:950