perfuse.c revision 1.8
1 /* $NetBSD: perfuse.c,v 1.8 2010/09/23 16:02:34 manu Exp $ */ 2 3 /*- 4 * Copyright (c) 2010 Emmanuel Dreyfus. All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 16 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 17 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 19 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 25 * POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include <stdio.h> 29 #include <unistd.h> 30 #include <stdlib.h> 31 #include <fcntl.h> 32 #include <string.h> 33 #include <errno.h> 34 #include <puffs.h> 35 #include <sys/types.h> 36 #include <sys/socket.h> 37 #include <sys/un.h> 38 #include <machine/vmparam.h> 39 40 #define LIBPERFUSE 41 #include "perfuse.h" 42 #include "perfuse_if.h" 43 #include "perfuse_priv.h" 44 45 int perfuse_diagflags = 0; /* global used only in DPRINTF/DERR/DWARN */ 46 47 static struct perfuse_state *init_state(void); 48 static int get_fd(const char *); 49 50 static struct perfuse_state * 51 init_state(void) 52 { 53 struct perfuse_state *ps; 54 55 if ((ps = malloc(sizeof(*ps))) == NULL) 56 DERR(EX_OSERR, "malloc failed"); 57 58 (void)memset(ps, 0, sizeof(*ps)); 59 ps->ps_max_write = UINT_MAX; 60 ps->ps_max_readahead = UINT_MAX; 61 TAILQ_INIT(&ps->ps_pnd); 62 63 return ps; 64 } 65 66 67 static int 68 get_fd(data) 69 const char *data; 70 { 71 char *string; 72 const char fdopt[] = "fd="; 73 char *lastp; 74 char *opt; 75 int fd = -1; 76 77 if ((string = strdup(data)) == NULL) 78 return -1; 79 80 for (opt = strtok_r(string, ",", &lastp); 81 opt != NULL; 82 opt = strtok_r(NULL, ",", &lastp)) { 83 if (strncmp(opt, fdopt, strlen(fdopt)) == 0) { 84 fd = atoi(opt + strlen(fdopt)); 85 break; 86 } 87 } 88 89 /* 90 * No file descriptor found 91 */ 92 if (fd == -1) 93 errno = EINVAL; 94 95 free(string); 96 return fd; 97 98 } 99 100 int 101 perfuse_open(path, flags, mode) 102 const char *path; 103 int flags; 104 mode_t mode; 105 { 106 int sv[2]; 107 struct sockaddr_un sun; 108 struct sockaddr *sa; 109 char progname[] = _PATH_PERFUSED; 110 char minus_i[] = "-i"; 111 char fdstr[16]; 112 char *const argv[] = { progname, minus_i, fdstr, NULL}; 113 char *const envp[] = { NULL }; 114 uint32_t opt; 115 116 if (strcmp(path, _PATH_FUSE) != 0) 117 return open(path, flags, mode); 118 119 if ((sv[0] = socket(PF_LOCAL, PERFUSE_SOCKTYPE, 0)) == -1) { 120 #ifdef PERFUSE_DEBUG 121 DWARN("%s:%d socket failed: %s", __func__, __LINE__); 122 #endif 123 return -1; 124 } 125 126 /* 127 * Set a buffer lentgh large enough so that any FUSE packet 128 * will fit. 129 */ 130 opt = FUSE_BUFSIZE; 131 if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 132 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 133 134 opt = FUSE_BUFSIZE; 135 if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 136 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 137 138 sa = (struct sockaddr *)(void *)&sun; 139 sun.sun_len = sizeof(sun); 140 sun.sun_family = AF_LOCAL; 141 (void)strcpy(sun.sun_path, path); 142 143 if (connect(sv[0], sa, (socklen_t)sun.sun_len) == 0) 144 return sv[0]; 145 146 147 /* 148 * Attempt to run perfused on our own 149 * if it does not run yet; In that case 150 * we will talk using a socketpair 151 * instead of /dev/fuse. 152 */ 153 if (socketpair(PF_LOCAL, PERFUSE_SOCKTYPE, 0, sv) != 0) { 154 DWARN("%s:%d: socketpair failed", __func__, __LINE__); 155 return -1; 156 } 157 158 /* 159 * Set a buffer lentgh large enough so that any FUSE packet 160 * will fit. 161 */ 162 opt = FUSE_BUFSIZE; 163 if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 164 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 165 166 opt = FUSE_BUFSIZE; 167 if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 168 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 169 170 opt = FUSE_BUFSIZE; 171 if (setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 172 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 173 174 opt = FUSE_BUFSIZE; 175 if (setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 176 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 177 178 /* 179 * Request peer credentials. This musr be done before first 180 * frame is sent. 181 */ 182 opt = 1; 183 if (setsockopt(sv[1], 0, LOCAL_CREDS, &opt, sizeof(opt)) != 0) 184 DWARN("%s: setsockopt LOCAL_CREDS failed", __func__); 185 186 (void)sprintf(fdstr, "%d", sv[1]); 187 188 switch(fork()) { 189 case -1: 190 #ifdef PERFUSE_DEBUG 191 DWARN("%s:%d: fork failed", __func__, __LINE__); 192 #endif 193 return -1; 194 /* NOTREACHED */ 195 break; 196 case 0: 197 (void)execve(argv[0], argv, envp); 198 #ifdef PERFUSE_DEBUG 199 DWARN("%s:%d: execve failed", __func__, __LINE__); 200 #endif 201 return -1; 202 /* NOTREACHED */ 203 break; 204 default: 205 break; 206 } 207 208 return sv[0]; 209 } 210 211 int 212 perfuse_mount(source, target, filesystemtype, mountflags, data) 213 const char *source; 214 const char *target; 215 const char *filesystemtype; 216 long mountflags; 217 const void *data; 218 { 219 int s; 220 size_t len; 221 struct perfuse_mount_out *pmo; 222 #if (PERFUSE_SOCKTYPE == SOCK_DGRAM) 223 struct sockaddr_storage ss; 224 struct sockaddr_un *sun; 225 struct sockaddr *sa; 226 socklen_t sa_len; 227 #endif 228 size_t sock_len; 229 char *frame; 230 char *cp; 231 232 #ifdef PERFUSE_DEBUG 233 if (perfuse_diagflags & PDF_MISC) 234 DPRINTF("%s(\"%s\", \"%s\", \"%s\", 0x%lx, \"%s\")\n", 235 __func__, source, target, filesystemtype, 236 mountflags, (const char *)data); 237 #endif 238 239 if ((s = get_fd(data)) == -1) 240 return -1; 241 242 /* 243 * If we are connected to /dev/fuse, we need a second 244 * socket to get replies from perfused. 245 * XXX This socket is not removed at exit time yet 246 */ 247 sock_len = 0; 248 #if (PERFUSE_SOCKTYPE == SOCK_DGRAM) 249 sa = (struct sockaddr *)(void *)&ss; 250 sun = (struct sockaddr_un *)(void *)&ss; 251 sa_len = sizeof(ss); 252 if ((getpeername(s, sa, &sa_len) == 0) && 253 (sa->sa_family = AF_LOCAL) && 254 (strcmp(sun->sun_path, _PATH_FUSE) == 0)) { 255 256 sun->sun_len = sizeof(*sun); 257 sun->sun_family = AF_LOCAL; 258 (void)sprintf(sun->sun_path, "%s/%s-%d", 259 _PATH_TMP, getprogname(), getpid()); 260 261 if (bind(s, sa, (socklen_t)sa->sa_len) != 0) 262 DERR(EX_OSERR, "%s:%d bind to \"%s\" failed", 263 __func__, __LINE__, sun->sun_path); 264 265 sock_len = strlen(sun->sun_path) + 1; 266 } 267 #endif /* PERFUSE_SOCKTYPE */ 268 269 len = sizeof(*pmo); 270 len += source ? (uint32_t)strlen(source) + 1 : 0; 271 len += target ? (uint32_t)strlen(target) + 1 : 0; 272 len += filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0; 273 len += data ? (uint32_t)strlen(data) + 1 : 0; 274 len += sock_len; 275 276 if ((frame = malloc(len)) == NULL) { 277 #ifdef PERFUSE_DEBUG 278 if (perfuse_diagflags & PDF_MISC) 279 DWARN("%s:%d malloc failed", __func__, __LINE__); 280 #endif 281 return -1; 282 } 283 284 pmo = (struct perfuse_mount_out *)(void *)frame; 285 pmo->pmo_len = len; 286 pmo->pmo_error = 0; 287 pmo->pmo_unique = (uint64_t)-1; 288 (void)strcpy(pmo->pmo_magic, PERFUSE_MOUNT_MAGIC); 289 290 pmo->pmo_source_len = source ? (uint32_t)strlen(source) + 1 : 0; 291 pmo->pmo_target_len = target ? (uint32_t)strlen(target) + 1: 0; 292 pmo->pmo_filesystemtype_len = 293 filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0; 294 pmo->pmo_mountflags = (uint32_t)mountflags; 295 pmo->pmo_data_len = data ? (uint32_t)strlen(data) + 1 : 0; 296 pmo->pmo_sock_len = sock_len; 297 298 cp = (char *)(void *)(pmo + 1); 299 300 if (source) { 301 (void)strcpy(cp, source); 302 cp += pmo->pmo_source_len; 303 } 304 305 if (target) { 306 (void)strcpy(cp, target); 307 cp += pmo->pmo_target_len; 308 } 309 310 if (filesystemtype) { 311 (void)strcpy(cp, filesystemtype); 312 cp += pmo->pmo_filesystemtype_len; 313 } 314 315 if (data) { 316 (void)strcpy(cp, data); 317 cp += pmo->pmo_data_len; 318 } 319 320 if (sock_len != 0) { 321 (void)strcpy(cp, sun->sun_path); 322 cp += pmo->pmo_sock_len; 323 } 324 325 if (send(s, frame, len, MSG_NOSIGNAL) != len) { 326 #ifdef PERFUSE_DEBUG 327 DWARN("%s:%d sendto failed", __func__, __LINE__); 328 #endif 329 return -1; 330 } 331 332 return 0; 333 } 334 335 336 uint64_t 337 perfuse_next_unique(pu) 338 struct puffs_usermount *pu; 339 { 340 struct perfuse_state *ps; 341 342 ps = puffs_getspecific(pu); 343 344 return ps->ps_unique++; 345 } 346 347 struct puffs_usermount * 348 perfuse_init(pc, pmi) 349 struct perfuse_callbacks *pc; 350 struct perfuse_mount_info *pmi; 351 { 352 struct perfuse_state *ps; 353 struct puffs_usermount *pu; 354 struct puffs_ops *pops; 355 char name[] = "perfuse"; 356 unsigned int puffs_flags; 357 struct puffs_node *pn_root; 358 struct puffs_pathobj *po_root; 359 360 ps = init_state(); 361 ps->ps_owner_uid = pmi->pmi_uid; 362 363 if (pmi->pmi_source) 364 ps->ps_source = strdup(pmi->pmi_source); 365 if (pmi->pmi_filesystemtype) 366 ps->ps_filesystemtype = strdup(pmi->pmi_filesystemtype); 367 ps->ps_target = strdup(pmi->pmi_target); 368 ps->ps_mountflags = pmi->pmi_mountflags; 369 370 /* 371 * Some options are forbidden for non root users 372 */ 373 if (ps->ps_owner_uid != 0) 374 ps->ps_mountflags |= MNT_NOSUID|MNT_NODEV; 375 376 PUFFSOP_INIT(pops); 377 PUFFSOP_SET(pops, perfuse, fs, unmount); 378 PUFFSOP_SET(pops, perfuse, fs, statvfs); 379 PUFFSOP_SET(pops, perfuse, fs, sync); 380 PUFFSOP_SET(pops, perfuse, node, lookup); 381 PUFFSOP_SET(pops, perfuse, node, create); 382 PUFFSOP_SET(pops, perfuse, node, mknod); 383 PUFFSOP_SET(pops, perfuse, node, open); 384 PUFFSOP_SET(pops, perfuse, node, close); 385 PUFFSOP_SET(pops, perfuse, node, access); 386 PUFFSOP_SET(pops, perfuse, node, getattr); 387 PUFFSOP_SET(pops, perfuse, node, setattr); 388 PUFFSOP_SET(pops, perfuse, node, poll); 389 #if 0 390 PUFFSOP_SET(pops, perfuse, node, mmap); 391 #endif 392 PUFFSOP_SET(pops, perfuse, node, fsync); 393 PUFFSOP_SET(pops, perfuse, node, seek); 394 PUFFSOP_SET(pops, perfuse, node, remove); 395 PUFFSOP_SET(pops, perfuse, node, link); 396 PUFFSOP_SET(pops, perfuse, node, rename); 397 PUFFSOP_SET(pops, perfuse, node, mkdir); 398 PUFFSOP_SET(pops, perfuse, node, rmdir); 399 PUFFSOP_SET(pops, perfuse, node, symlink); 400 PUFFSOP_SET(pops, perfuse, node, readdir); 401 PUFFSOP_SET(pops, perfuse, node, readlink); 402 PUFFSOP_SET(pops, perfuse, node, reclaim); 403 PUFFSOP_SET(pops, perfuse, node, inactive); 404 PUFFSOP_SET(pops, perfuse, node, print); 405 PUFFSOP_SET(pops, perfuse, node, advlock); 406 PUFFSOP_SET(pops, perfuse, node, read); 407 PUFFSOP_SET(pops, perfuse, node, write); 408 409 puffs_flags = PUFFS_FLAG_BUILDPATH | PUFFS_FLAG_HASHPATH | 410 PUFFS_KFLAG_WTCACHE | PUFFS_KFLAG_IAONDEMAND; 411 if (perfuse_diagflags & PDF_PUFFS) 412 puffs_flags |= PUFFS_FLAG_OPDUMP; 413 414 if ((pu = puffs_init(pops, _PATH_PUFFS, name, ps, puffs_flags)) == NULL) 415 DERR(EX_OSERR, "puffs_init failed"); 416 417 ps->ps_pu = pu; 418 419 /* 420 * Setup filesystem root 421 */ 422 pn_root = perfuse_new_pn(pu, NULL); 423 PERFUSE_NODE_DATA(pn_root)->pnd_ino = FUSE_ROOT_ID; 424 PERFUSE_NODE_DATA(pn_root)->pnd_parent = pn_root; 425 puffs_setroot(pu, pn_root); 426 ps->ps_fsid = pn_root->pn_va.va_fsid; 427 428 po_root = puffs_getrootpathobj(pu); 429 if ((po_root->po_path = strdup("/")) == NULL) 430 DERRX(EX_OSERR, "perfuse_mount_start() failed"); 431 432 po_root->po_len = 1; 433 puffs_path_buildhash(pu, po_root); 434 435 puffs_vattr_null(&pn_root->pn_va); 436 pn_root->pn_va.va_type = VDIR; 437 pn_root->pn_va.va_mode = 0755; 438 439 ps->ps_root = pn_root; 440 441 /* 442 * Callbacks 443 */ 444 ps->ps_new_msg = pc->pc_new_msg; 445 ps->ps_xchg_msg = pc->pc_xchg_msg; 446 ps->ps_destroy_msg = pc->pc_destroy_msg; 447 ps->ps_get_inhdr = pc->pc_get_inhdr; 448 ps->ps_get_inpayload = pc->pc_get_inpayload; 449 ps->ps_get_outhdr = pc->pc_get_outhdr; 450 ps->ps_get_outpayload = pc->pc_get_outpayload; 451 452 return pu; 453 } 454 455 void 456 perfuse_setspecific(pu, priv) 457 struct puffs_usermount *pu; 458 void *priv; 459 { 460 struct perfuse_state *ps; 461 462 ps = puffs_getspecific(pu); 463 ps->ps_private = priv; 464 465 return; 466 } 467 468 void * 469 perfuse_getspecific(pu) 470 struct puffs_usermount *pu; 471 { 472 struct perfuse_state *ps; 473 474 ps = puffs_getspecific(pu); 475 476 return ps->ps_private; 477 } 478 479 int 480 perfuse_inloop(pu) 481 struct puffs_usermount *pu; 482 { 483 struct perfuse_state *ps; 484 485 ps = puffs_getspecific(pu); 486 487 return ps->ps_flags & PS_INLOOP; 488 } 489 490 int 491 perfuse_mainloop(pu) 492 struct puffs_usermount *pu; 493 { 494 struct perfuse_state *ps; 495 496 ps = puffs_getspecific(pu); 497 498 ps->ps_flags |= PS_INLOOP; 499 if (puffs_mainloop(ps->ps_pu) != 0) 500 DERR(EX_OSERR, "puffs_mainloop failed"); 501 DERR(EX_OSERR, "puffs_mainloop exit"); 502 503 /* NOTREACHED */ 504 return -1; 505 } 506 507 /* ARGSUSED0 */ 508 uint64_t 509 perfuse_get_ino(pu, opc) 510 struct puffs_usermount *pu; 511 puffs_cookie_t opc; 512 { 513 return PERFUSE_NODE_DATA(opc)->pnd_ino; 514 } 515 516 int 517 perfuse_unmount(pu) 518 struct puffs_usermount *pu; 519 { 520 struct perfuse_state *ps; 521 522 ps = puffs_getspecific(pu); 523 524 return unmount(ps->ps_target, MNT_FORCE); 525 } 526
Indexes created Thu Oct 02 10:09:58 GMT 2025