helper.c (15469B)
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 COPYING.LIB. 11 */ 12 13 #include "qemu/osdep.h" 14 #include "fuse_i.h" 15 #include "fuse_lowlevel.h" 16 #include "fuse_misc.h" 17 #include "fuse_opt.h" 18 19 #include <sys/param.h> 20 #include <sys/resource.h> 21 22 #define FUSE_HELPER_OPT(t, p) \ 23 { \ 24 t, offsetof(struct fuse_cmdline_opts, p), 1 \ 25 } 26 #define FUSE_HELPER_OPT_VALUE(t, p, v) \ 27 { \ 28 t, offsetof(struct fuse_cmdline_opts, p), v \ 29 } 30 31 static const struct fuse_opt fuse_helper_opts[] = { 32 FUSE_HELPER_OPT("-h", show_help), 33 FUSE_HELPER_OPT("--help", show_help), 34 FUSE_HELPER_OPT("-V", show_version), 35 FUSE_HELPER_OPT("--version", show_version), 36 FUSE_HELPER_OPT("--print-capabilities", print_capabilities), 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_VALUE("--daemonize", foreground, 0), 45 FUSE_HELPER_OPT("fsname=", nodefault_subtype), 46 FUSE_OPT_KEY("fsname=", FUSE_OPT_KEY_KEEP), 47 FUSE_HELPER_OPT("subtype=", nodefault_subtype), 48 FUSE_OPT_KEY("subtype=", FUSE_OPT_KEY_KEEP), 49 FUSE_HELPER_OPT("max_idle_threads=%u", max_idle_threads), 50 FUSE_HELPER_OPT("--rlimit-nofile=%lu", rlimit_nofile), 51 FUSE_HELPER_OPT("--syslog", syslog), 52 FUSE_HELPER_OPT_VALUE("log_level=debug", log_level, FUSE_LOG_DEBUG), 53 FUSE_HELPER_OPT_VALUE("log_level=info", log_level, FUSE_LOG_INFO), 54 FUSE_HELPER_OPT_VALUE("log_level=warn", log_level, FUSE_LOG_WARNING), 55 FUSE_HELPER_OPT_VALUE("log_level=err", log_level, FUSE_LOG_ERR), 56 FUSE_OPT_END 57 }; 58 59 struct fuse_conn_info_opts { 60 int atomic_o_trunc; 61 int no_remote_posix_lock; 62 int no_remote_flock; 63 int splice_write; 64 int splice_move; 65 int splice_read; 66 int no_splice_write; 67 int no_splice_move; 68 int no_splice_read; 69 int auto_inval_data; 70 int no_auto_inval_data; 71 int no_readdirplus; 72 int no_readdirplus_auto; 73 int async_dio; 74 int no_async_dio; 75 int writeback_cache; 76 int no_writeback_cache; 77 int async_read; 78 int sync_read; 79 unsigned max_write; 80 unsigned max_readahead; 81 unsigned max_background; 82 unsigned congestion_threshold; 83 unsigned time_gran; 84 int set_max_write; 85 int set_max_readahead; 86 int set_max_background; 87 int set_congestion_threshold; 88 int set_time_gran; 89 }; 90 91 #define CONN_OPTION(t, p, v) \ 92 { \ 93 t, offsetof(struct fuse_conn_info_opts, p), v \ 94 } 95 static const struct fuse_opt conn_info_opt_spec[] = { 96 CONN_OPTION("max_write=%u", max_write, 0), 97 CONN_OPTION("max_write=", set_max_write, 1), 98 CONN_OPTION("max_readahead=%u", max_readahead, 0), 99 CONN_OPTION("max_readahead=", set_max_readahead, 1), 100 CONN_OPTION("max_background=%u", max_background, 0), 101 CONN_OPTION("max_background=", set_max_background, 1), 102 CONN_OPTION("congestion_threshold=%u", congestion_threshold, 0), 103 CONN_OPTION("congestion_threshold=", set_congestion_threshold, 1), 104 CONN_OPTION("sync_read", sync_read, 1), 105 CONN_OPTION("async_read", async_read, 1), 106 CONN_OPTION("atomic_o_trunc", atomic_o_trunc, 1), 107 CONN_OPTION("no_remote_lock", no_remote_posix_lock, 1), 108 CONN_OPTION("no_remote_lock", no_remote_flock, 1), 109 CONN_OPTION("no_remote_flock", no_remote_flock, 1), 110 CONN_OPTION("no_remote_posix_lock", no_remote_posix_lock, 1), 111 CONN_OPTION("splice_write", splice_write, 1), 112 CONN_OPTION("no_splice_write", no_splice_write, 1), 113 CONN_OPTION("splice_move", splice_move, 1), 114 CONN_OPTION("no_splice_move", no_splice_move, 1), 115 CONN_OPTION("splice_read", splice_read, 1), 116 CONN_OPTION("no_splice_read", no_splice_read, 1), 117 CONN_OPTION("auto_inval_data", auto_inval_data, 1), 118 CONN_OPTION("no_auto_inval_data", no_auto_inval_data, 1), 119 CONN_OPTION("readdirplus=no", no_readdirplus, 1), 120 CONN_OPTION("readdirplus=yes", no_readdirplus, 0), 121 CONN_OPTION("readdirplus=yes", no_readdirplus_auto, 1), 122 CONN_OPTION("readdirplus=auto", no_readdirplus, 0), 123 CONN_OPTION("readdirplus=auto", no_readdirplus_auto, 0), 124 CONN_OPTION("async_dio", async_dio, 1), 125 CONN_OPTION("no_async_dio", no_async_dio, 1), 126 CONN_OPTION("writeback_cache", writeback_cache, 1), 127 CONN_OPTION("no_writeback_cache", no_writeback_cache, 1), 128 CONN_OPTION("time_gran=%u", time_gran, 0), 129 CONN_OPTION("time_gran=", set_time_gran, 1), 130 FUSE_OPT_END 131 }; 132 133 134 void fuse_cmdline_help(void) 135 { 136 printf(" -h --help print help\n" 137 " -V --version print version\n" 138 " --print-capabilities print vhost-user.json\n" 139 " -d -o debug enable debug output (implies -f)\n" 140 " --syslog log to syslog (default stderr)\n" 141 " -f foreground operation\n" 142 " --daemonize run in background\n" 143 " -o cache=<mode> cache mode. could be one of \"auto, " 144 "always, none\"\n" 145 " default: auto\n" 146 " -o flock|no_flock enable/disable flock\n" 147 " default: no_flock\n" 148 " -o log_level=<level> log level, default to \"info\"\n" 149 " level could be one of \"debug, " 150 "info, warn, err\"\n" 151 " -o max_idle_threads the maximum number of idle worker " 152 "threads\n" 153 " allowed (default: 10)\n" 154 " -o posix_lock|no_posix_lock\n" 155 " enable/disable remote posix lock\n" 156 " default: no_posix_lock\n" 157 " -o readdirplus|no_readdirplus\n" 158 " enable/disable readirplus\n" 159 " default: readdirplus except with " 160 "cache=none\n" 161 " -o sandbox=namespace|chroot\n" 162 " sandboxing mode:\n" 163 " - namespace: mount, pid, and net\n" 164 " namespaces with pivot_root(2)\n" 165 " into shared directory\n" 166 " - chroot: chroot(2) into shared\n" 167 " directory (use in containers)\n" 168 " default: namespace\n" 169 " -o timeout=<number> I/O timeout (seconds)\n" 170 " default: depends on cache= option.\n" 171 " -o writeback|no_writeback enable/disable writeback cache\n" 172 " default: no_writeback\n" 173 " -o xattr|no_xattr enable/disable xattr\n" 174 " default: no_xattr\n" 175 " -o xattrmap=<mapping> Enable xattr mapping (enables xattr)\n" 176 " <mapping> is a string consists of a series of rules\n" 177 " e.g. -o xattrmap=:map::user.virtiofs.:\n" 178 " -o modcaps=CAPLIST Modify the list of capabilities\n" 179 " e.g. -o modcaps=+sys_admin:-chown\n" 180 " --rlimit-nofile=<num> set maximum number of file descriptors\n" 181 " (0 leaves rlimit unchanged)\n" 182 " default: min(1000000, fs.file-max - 16384)\n" 183 " if the current rlimit is lower\n" 184 " -o allow_direct_io|no_allow_direct_io\n" 185 " retain/discard O_DIRECT flags passed down\n" 186 " to virtiofsd from guest applications.\n" 187 " default: no_allow_direct_io\n" 188 " -o announce_submounts Announce sub-mount points to the guest\n" 189 " -o posix_acl/no_posix_acl Enable/Disable posix_acl. (default: disabled)\n" 190 " -o security_label/no_security_label Enable/Disable security label. (default: disabled)\n" 191 " -o killpriv_v2/no_killpriv_v2\n" 192 " Enable/Disable FUSE_HANDLE_KILLPRIV_V2.\n" 193 " (default: enabled as long as client supports it)\n" 194 ); 195 } 196 197 static int fuse_helper_opt_proc(void *data, const char *arg, int key, 198 struct fuse_args *outargs) 199 { 200 (void)data; 201 (void)outargs; 202 203 switch (key) { 204 case FUSE_OPT_KEY_NONOPT: 205 fuse_log(FUSE_LOG_ERR, "fuse: invalid argument `%s'\n", arg); 206 return -1; 207 208 default: 209 /* Pass through unknown options */ 210 return 1; 211 } 212 } 213 214 static unsigned long get_default_rlimit_nofile(void) 215 { 216 g_autofree gchar *file_max_str = NULL; 217 const rlim_t reserved_fds = 16384; /* leave at least this many fds free */ 218 rlim_t max_fds = 1000000; /* our default RLIMIT_NOFILE target */ 219 rlim_t file_max; 220 struct rlimit rlim; 221 222 /* 223 * Reduce max_fds below the system-wide maximum, if necessary. This 224 * ensures there are fds available for other processes so we don't 225 * cause resource exhaustion. 226 */ 227 if (!g_file_get_contents("/proc/sys/fs/file-max", &file_max_str, 228 NULL, NULL)) { 229 fuse_log(FUSE_LOG_ERR, "can't read /proc/sys/fs/file-max\n"); 230 exit(1); 231 } 232 file_max = g_ascii_strtoull(file_max_str, NULL, 10); 233 if (file_max < 2 * reserved_fds) { 234 fuse_log(FUSE_LOG_ERR, 235 "The fs.file-max sysctl is too low (%lu) to allow a " 236 "reasonable number of open files.\n", 237 (unsigned long)file_max); 238 exit(1); 239 } 240 max_fds = MIN(file_max - reserved_fds, max_fds); 241 242 if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) { 243 fuse_log(FUSE_LOG_ERR, "getrlimit(RLIMIT_NOFILE): %m\n"); 244 exit(1); 245 } 246 247 if (rlim.rlim_cur >= max_fds) { 248 return 0; /* we have more fds available than required! */ 249 } 250 return max_fds; 251 } 252 253 int fuse_parse_cmdline(struct fuse_args *args, struct fuse_cmdline_opts *opts) 254 { 255 memset(opts, 0, sizeof(struct fuse_cmdline_opts)); 256 257 opts->max_idle_threads = 10; 258 opts->rlimit_nofile = get_default_rlimit_nofile(); 259 opts->foreground = 1; 260 261 if (fuse_opt_parse(args, opts, fuse_helper_opts, fuse_helper_opt_proc) == 262 -1) { 263 return -1; 264 } 265 266 return 0; 267 } 268 269 270 int fuse_daemonize(int foreground) 271 { 272 int ret = 0, rett; 273 if (!foreground) { 274 int nullfd; 275 int waiter[2]; 276 char completed; 277 278 if (!g_unix_open_pipe(waiter, FD_CLOEXEC, NULL)) { 279 fuse_log(FUSE_LOG_ERR, "fuse_daemonize: pipe: %s\n", 280 strerror(errno)); 281 return -1; 282 } 283 284 /* 285 * demonize current process by forking it and killing the 286 * parent. This makes current process as a child of 'init'. 287 */ 288 switch (fork()) { 289 case -1: 290 fuse_log(FUSE_LOG_ERR, "fuse_daemonize: fork: %s\n", 291 strerror(errno)); 292 return -1; 293 case 0: 294 break; 295 default: 296 _exit(read(waiter[0], &completed, 297 sizeof(completed) != sizeof(completed))); 298 } 299 300 if (setsid() == -1) { 301 fuse_log(FUSE_LOG_ERR, "fuse_daemonize: setsid: %s\n", 302 strerror(errno)); 303 return -1; 304 } 305 306 ret = chdir("/"); 307 308 nullfd = open("/dev/null", O_RDWR, 0); 309 if (nullfd != -1) { 310 rett = dup2(nullfd, 0); 311 if (!ret) { 312 ret = rett; 313 } 314 rett = dup2(nullfd, 1); 315 if (!ret) { 316 ret = rett; 317 } 318 rett = dup2(nullfd, 2); 319 if (!ret) { 320 ret = rett; 321 } 322 if (nullfd > 2) { 323 close(nullfd); 324 } 325 } 326 327 /* Propagate completion of daemon initialization */ 328 completed = 1; 329 rett = write(waiter[1], &completed, sizeof(completed)); 330 if (!ret) { 331 ret = rett; 332 } 333 close(waiter[0]); 334 close(waiter[1]); 335 } else { 336 ret = chdir("/"); 337 } 338 return ret; 339 } 340 341 void fuse_apply_conn_info_opts(struct fuse_conn_info_opts *opts, 342 struct fuse_conn_info *conn) 343 { 344 if (opts->set_max_write) { 345 conn->max_write = opts->max_write; 346 } 347 if (opts->set_max_background) { 348 conn->max_background = opts->max_background; 349 } 350 if (opts->set_congestion_threshold) { 351 conn->congestion_threshold = opts->congestion_threshold; 352 } 353 if (opts->set_time_gran) { 354 conn->time_gran = opts->time_gran; 355 } 356 if (opts->set_max_readahead) { 357 conn->max_readahead = opts->max_readahead; 358 } 359 360 #define LL_ENABLE(cond, cap) \ 361 if (cond) \ 362 conn->want |= (cap) 363 #define LL_DISABLE(cond, cap) \ 364 if (cond) \ 365 conn->want &= ~(cap) 366 367 LL_ENABLE(opts->splice_read, FUSE_CAP_SPLICE_READ); 368 LL_DISABLE(opts->no_splice_read, FUSE_CAP_SPLICE_READ); 369 370 LL_ENABLE(opts->splice_write, FUSE_CAP_SPLICE_WRITE); 371 LL_DISABLE(opts->no_splice_write, FUSE_CAP_SPLICE_WRITE); 372 373 LL_ENABLE(opts->splice_move, FUSE_CAP_SPLICE_MOVE); 374 LL_DISABLE(opts->no_splice_move, FUSE_CAP_SPLICE_MOVE); 375 376 LL_ENABLE(opts->auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA); 377 LL_DISABLE(opts->no_auto_inval_data, FUSE_CAP_AUTO_INVAL_DATA); 378 379 LL_DISABLE(opts->no_readdirplus, FUSE_CAP_READDIRPLUS); 380 LL_DISABLE(opts->no_readdirplus_auto, FUSE_CAP_READDIRPLUS_AUTO); 381 382 LL_ENABLE(opts->async_dio, FUSE_CAP_ASYNC_DIO); 383 LL_DISABLE(opts->no_async_dio, FUSE_CAP_ASYNC_DIO); 384 385 LL_ENABLE(opts->writeback_cache, FUSE_CAP_WRITEBACK_CACHE); 386 LL_DISABLE(opts->no_writeback_cache, FUSE_CAP_WRITEBACK_CACHE); 387 388 LL_ENABLE(opts->async_read, FUSE_CAP_ASYNC_READ); 389 LL_DISABLE(opts->sync_read, FUSE_CAP_ASYNC_READ); 390 391 LL_DISABLE(opts->no_remote_posix_lock, FUSE_CAP_POSIX_LOCKS); 392 LL_DISABLE(opts->no_remote_flock, FUSE_CAP_FLOCK_LOCKS); 393 } 394 395 struct fuse_conn_info_opts *fuse_parse_conn_info_opts(struct fuse_args *args) 396 { 397 struct fuse_conn_info_opts *opts; 398 399 opts = calloc(1, sizeof(struct fuse_conn_info_opts)); 400 if (opts == NULL) { 401 fuse_log(FUSE_LOG_ERR, "calloc failed\n"); 402 return NULL; 403 } 404 if (fuse_opt_parse(args, opts, conn_info_opt_spec, NULL) == -1) { 405 free(opts); 406 return NULL; 407 } 408 return opts; 409 }