perfuse.c revision 1.10
1 /* $NetBSD: perfuse.c,v 1.10 2010/10/03 05:46:47 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 62 return ps; 63 } 64 65 66 static int 67 get_fd(data) 68 const char *data; 69 { 70 char *string; 71 const char fdopt[] = "fd="; 72 char *lastp; 73 char *opt; 74 int fd = -1; 75 76 if ((string = strdup(data)) == NULL) 77 return -1; 78 79 for (opt = strtok_r(string, ",", &lastp); 80 opt != NULL; 81 opt = strtok_r(NULL, ",", &lastp)) { 82 if (strncmp(opt, fdopt, strlen(fdopt)) == 0) { 83 fd = atoi(opt + strlen(fdopt)); 84 break; 85 } 86 } 87 88 /* 89 * No file descriptor found 90 */ 91 if (fd == -1) 92 errno = EINVAL; 93 94 free(string); 95 return fd; 96 97 } 98 99 int 100 perfuse_open(path, flags, mode) 101 const char *path; 102 int flags; 103 mode_t mode; 104 { 105 int sv[2]; 106 struct sockaddr_un sun; 107 struct sockaddr *sa; 108 char progname[] = _PATH_PERFUSED; 109 char minus_i[] = "-i"; 110 char fdstr[16]; 111 char *const argv[] = { progname, minus_i, fdstr, NULL}; 112 char *const envp[] = { NULL }; 113 uint32_t opt; 114 115 if (strcmp(path, _PATH_FUSE) != 0) 116 return open(path, flags, mode); 117 118 if ((sv[0] = socket(PF_LOCAL, PERFUSE_SOCKTYPE, 0)) == -1) { 119 #ifdef PERFUSE_DEBUG 120 DWARN("%s:%d socket failed: %s", __func__, __LINE__); 121 #endif 122 return -1; 123 } 124 125 /* 126 * Set a buffer lentgh large enough so that any FUSE packet 127 * will fit. 128 */ 129 opt = FUSE_BUFSIZE; 130 if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 131 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 132 133 opt = FUSE_BUFSIZE; 134 if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 135 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 136 137 sa = (struct sockaddr *)(void *)&sun; 138 sun.sun_len = sizeof(sun); 139 sun.sun_family = AF_LOCAL; 140 (void)strcpy(sun.sun_path, path); 141 142 if (connect(sv[0], sa, (socklen_t)sun.sun_len) == 0) 143 return sv[0]; 144 145 146 /* 147 * Attempt to run perfused on our own 148 * if it does not run yet; In that case 149 * we will talk using a socketpair 150 * instead of /dev/fuse. 151 */ 152 if (socketpair(PF_LOCAL, PERFUSE_SOCKTYPE, 0, sv) != 0) { 153 DWARN("%s:%d: socketpair failed", __func__, __LINE__); 154 return -1; 155 } 156 157 /* 158 * Set a buffer lentgh large enough so that any FUSE packet 159 * will fit. 160 */ 161 opt = FUSE_BUFSIZE; 162 if (setsockopt(sv[0], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 163 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 164 165 opt = FUSE_BUFSIZE; 166 if (setsockopt(sv[0], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 167 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 168 169 opt = FUSE_BUFSIZE; 170 if (setsockopt(sv[1], SOL_SOCKET, SO_SNDBUF, &opt, sizeof(opt)) != 0) 171 DWARN("%s: setsockopt SO_SNDBUF to %d failed", __func__, opt); 172 173 opt = FUSE_BUFSIZE; 174 if (setsockopt(sv[1], SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)) != 0) 175 DWARN("%s: setsockopt SO_RCVBUF to %d failed", __func__, opt); 176 177 /* 178 * Request peer credentials. This musr be done before first 179 * frame is sent. 180 */ 181 opt = 1; 182 if (setsockopt(sv[1], 0, LOCAL_CREDS, &opt, sizeof(opt)) != 0) 183 DWARN("%s: setsockopt LOCAL_CREDS failed", __func__); 184 185 (void)sprintf(fdstr, "%d", sv[1]); 186 187 switch(fork()) { 188 case -1: 189 #ifdef PERFUSE_DEBUG 190 DWARN("%s:%d: fork failed", __func__, __LINE__); 191 #endif 192 return -1; 193 /* NOTREACHED */ 194 break; 195 case 0: 196 (void)execve(argv[0], argv, envp); 197 #ifdef PERFUSE_DEBUG 198 DWARN("%s:%d: execve failed", __func__, __LINE__); 199 #endif 200 return -1; 201 /* NOTREACHED */ 202 break; 203 default: 204 break; 205 } 206 207 return sv[0]; 208 } 209 210 int 211 perfuse_mount(source, target, filesystemtype, mountflags, data) 212 const char *source; 213 const char *target; 214 const char *filesystemtype; 215 long mountflags; 216 const void *data; 217 { 218 int s; 219 size_t len; 220 struct perfuse_mount_out *pmo; 221 #if (PERFUSE_SOCKTYPE == SOCK_DGRAM) 222 struct sockaddr_storage ss; 223 struct sockaddr_un *sun; 224 struct sockaddr *sa; 225 socklen_t sa_len; 226 #endif 227 size_t sock_len; 228 char *frame; 229 char *cp; 230 231 #ifdef PERFUSE_DEBUG 232 if (perfuse_diagflags & PDF_MISC) 233 DPRINTF("%s(\"%s\", \"%s\", \"%s\", 0x%lx, \"%s\")\n", 234 __func__, source, target, filesystemtype, 235 mountflags, (const char *)data); 236 #endif 237 238 if ((s = get_fd(data)) == -1) 239 return -1; 240 241 /* 242 * If we are connected to /dev/fuse, we need a second 243 * socket to get replies from perfused. 244 * XXX This socket is not removed at exit time yet 245 */ 246 sock_len = 0; 247 #if (PERFUSE_SOCKTYPE == SOCK_DGRAM) 248 sa = (struct sockaddr *)(void *)&ss; 249 sun = (struct sockaddr_un *)(void *)&ss; 250 sa_len = sizeof(ss); 251 if ((getpeername(s, sa, &sa_len) == 0) && 252 (sa->sa_family = AF_LOCAL) && 253 (strcmp(sun->sun_path, _PATH_FUSE) == 0)) { 254 255 sun->sun_len = sizeof(*sun); 256 sun->sun_family = AF_LOCAL; 257 (void)sprintf(sun->sun_path, "%s/%s-%d", 258 _PATH_TMP, getprogname(), getpid()); 259 260 if (bind(s, sa, (socklen_t)sa->sa_len) != 0) 261 DERR(EX_OSERR, "%s:%d bind to \"%s\" failed", 262 __func__, __LINE__, sun->sun_path); 263 264 sock_len = strlen(sun->sun_path) + 1; 265 } 266 #endif /* PERFUSE_SOCKTYPE */ 267 268 len = sizeof(*pmo); 269 len += source ? (uint32_t)strlen(source) + 1 : 0; 270 len += target ? (uint32_t)strlen(target) + 1 : 0; 271 len += filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0; 272 len += data ? (uint32_t)strlen(data) + 1 : 0; 273 len += sock_len; 274 275 if ((frame = malloc(len)) == NULL) { 276 #ifdef PERFUSE_DEBUG 277 if (perfuse_diagflags & PDF_MISC) 278 DWARN("%s:%d malloc failed", __func__, __LINE__); 279 #endif 280 return -1; 281 } 282 283 pmo = (struct perfuse_mount_out *)(void *)frame; 284 pmo->pmo_len = len; 285 pmo->pmo_error = 0; 286 pmo->pmo_unique = (uint64_t)-1; 287 (void)strcpy(pmo->pmo_magic, PERFUSE_MOUNT_MAGIC); 288 289 pmo->pmo_source_len = source ? (uint32_t)strlen(source) + 1 : 0; 290 pmo->pmo_target_len = target ? (uint32_t)strlen(target) + 1: 0; 291 pmo->pmo_filesystemtype_len = 292 filesystemtype ? (uint32_t)strlen(filesystemtype) + 1 : 0; 293 pmo->pmo_mountflags = (uint32_t)mountflags; 294 pmo->pmo_data_len = data ? (uint32_t)strlen(data) + 1 : 0; 295 pmo->pmo_sock_len = sock_len; 296 297 cp = (char *)(void *)(pmo + 1); 298 299 if (source) { 300 (void)strcpy(cp, source); 301 cp += pmo->pmo_source_len; 302 } 303 304 if (target) { 305 (void)strcpy(cp, target); 306 cp += pmo->pmo_target_len; 307 } 308 309 if (filesystemtype) { 310 (void)strcpy(cp, filesystemtype); 311 cp += pmo->pmo_filesystemtype_len; 312 } 313 314 if (data) { 315 (void)strcpy(cp, data); 316 cp += pmo->pmo_data_len; 317 } 318 319 if (sock_len != 0) { 320 (void)strcpy(cp, sun->sun_path); 321 cp += pmo->pmo_sock_len; 322 } 323 324 if (send(s, frame, len, MSG_NOSIGNAL) != len) { 325 #ifdef PERFUSE_DEBUG 326 DWARN("%s:%d sendto failed", __func__, __LINE__); 327 #endif 328 return -1; 329 } 330 331 return 0; 332 } 333 334 335 uint64_t 336 perfuse_next_unique(pu) 337 struct puffs_usermount *pu; 338 { 339 struct perfuse_state *ps; 340 341 ps = puffs_getspecific(pu); 342 343 return ps->ps_unique++; 344 } 345 346 struct puffs_usermount * 347 perfuse_init(pc, pmi) 348 struct perfuse_callbacks *pc; 349 struct perfuse_mount_info *pmi; 350 { 351 struct perfuse_state *ps; 352 struct puffs_usermount *pu; 353 struct puffs_ops *pops; 354 char name[] = "perfuse"; 355 unsigned int puffs_flags; 356 struct puffs_node *pn_root; 357 struct puffs_pathobj *po_root; 358 359 ps = init_state(); 360 ps->ps_owner_uid = pmi->pmi_uid; 361 362 if (pmi->pmi_source) 363 ps->ps_source = strdup(pmi->pmi_source); 364 if (pmi->pmi_filesystemtype) 365 ps->ps_filesystemtype = strdup(pmi->pmi_filesystemtype); 366 ps->ps_target = strdup(pmi->pmi_target); 367 ps->ps_mountflags = pmi->pmi_mountflags; 368 369 /* 370 * Some options are forbidden for non root users 371 */ 372 if (ps->ps_owner_uid != 0) 373 ps->ps_mountflags |= MNT_NOSUID|MNT_NODEV; 374 375 PUFFSOP_INIT(pops); 376 PUFFSOP_SET(pops, perfuse, fs, unmount); 377 PUFFSOP_SET(pops, perfuse, fs, statvfs); 378 PUFFSOP_SET(pops, perfuse, fs, sync); 379 PUFFSOP_SET(pops, perfuse, node, lookup); 380 PUFFSOP_SET(pops, perfuse, node, create); 381 PUFFSOP_SET(pops, perfuse, node, mknod); 382 PUFFSOP_SET(pops, perfuse, node, open); 383 PUFFSOP_SET(pops, perfuse, node, close); 384 PUFFSOP_SET(pops, perfuse, node, access); 385 PUFFSOP_SET(pops, perfuse, node, getattr); 386 PUFFSOP_SET(pops, perfuse, node, setattr); 387 PUFFSOP_SET(pops, perfuse, node, poll); 388 #if 0 389 PUFFSOP_SET(pops, perfuse, node, mmap); 390 #endif 391 PUFFSOP_SET(pops, perfuse, node, fsync); 392 PUFFSOP_SET(pops, perfuse, node, seek); 393 PUFFSOP_SET(pops, perfuse, node, remove); 394 PUFFSOP_SET(pops, perfuse, node, link); 395 PUFFSOP_SET(pops, perfuse, node, rename); 396 PUFFSOP_SET(pops, perfuse, node, mkdir); 397 PUFFSOP_SET(pops, perfuse, node, rmdir); 398 PUFFSOP_SET(pops, perfuse, node, symlink); 399 PUFFSOP_SET(pops, perfuse, node, readdir); 400 PUFFSOP_SET(pops, perfuse, node, readlink); 401 PUFFSOP_SET(pops, perfuse, node, reclaim); 402 PUFFSOP_SET(pops, perfuse, node, inactive); 403 PUFFSOP_SET(pops, perfuse, node, print); 404 PUFFSOP_SET(pops, perfuse, node, advlock); 405 PUFFSOP_SET(pops, perfuse, node, read); 406 PUFFSOP_SET(pops, perfuse, node, write); 407 408 puffs_flags = PUFFS_KFLAG_WTCACHE; 409 410 if (perfuse_diagflags & PDF_PUFFS) 411 puffs_flags |= PUFFS_FLAG_OPDUMP; 412 413 if ((pu = puffs_init(pops, _PATH_PUFFS, name, ps, puffs_flags)) == NULL) 414 DERR(EX_OSERR, "puffs_init failed"); 415 416 ps->ps_pu = pu; 417 418 /* 419 * Setup filesystem root 420 */ 421 pn_root = perfuse_new_pn(pu, "", NULL); 422 PERFUSE_NODE_DATA(pn_root)->pnd_ino = FUSE_ROOT_ID; 423 PERFUSE_NODE_DATA(pn_root)->pnd_parent = pn_root; 424 puffs_setroot(pu, pn_root); 425 ps->ps_fsid = pn_root->pn_va.va_fsid; 426 427 po_root = puffs_getrootpathobj(pu); 428 if ((po_root->po_path = strdup("/")) == NULL) 429 DERRX(EX_OSERR, "perfuse_mount_start() failed"); 430 431 po_root->po_len = 1; 432 puffs_path_buildhash(pu, po_root); 433 434 puffs_vattr_null(&pn_root->pn_va); 435 pn_root->pn_va.va_type = VDIR; 436 pn_root->pn_va.va_mode = 0755; 437 438 ps->ps_root = pn_root; 439 440 /* 441 * Callbacks 442 */ 443 ps->ps_new_msg = pc->pc_new_msg; 444 ps->ps_xchg_msg = pc->pc_xchg_msg; 445 ps->ps_destroy_msg = pc->pc_destroy_msg; 446 ps->ps_get_inhdr = pc->pc_get_inhdr; 447 ps->ps_get_inpayload = pc->pc_get_inpayload; 448 ps->ps_get_outhdr = pc->pc_get_outhdr; 449 ps->ps_get_outpayload = pc->pc_get_outpayload; 450 451 return pu; 452 } 453 454 void 455 perfuse_setspecific(pu, priv) 456 struct puffs_usermount *pu; 457 void *priv; 458 { 459 struct perfuse_state *ps; 460 461 ps = puffs_getspecific(pu); 462 ps->ps_private = priv; 463 464 return; 465 } 466 467 void * 468 perfuse_getspecific(pu) 469 struct puffs_usermount *pu; 470 { 471 struct perfuse_state *ps; 472 473 ps = puffs_getspecific(pu); 474 475 return ps->ps_private; 476 } 477 478 int 479 perfuse_inloop(pu) 480 struct puffs_usermount *pu; 481 { 482 struct perfuse_state *ps; 483 484 ps = puffs_getspecific(pu); 485 486 return ps->ps_flags & PS_INLOOP; 487 } 488 489 int 490 perfuse_mainloop(pu) 491 struct puffs_usermount *pu; 492 { 493 struct perfuse_state *ps; 494 495 ps = puffs_getspecific(pu); 496 497 ps->ps_flags |= PS_INLOOP; 498 if (puffs_mainloop(ps->ps_pu) != 0) 499 DERR(EX_OSERR, "puffs_mainloop failed"); 500 DERR(EX_OSERR, "puffs_mainloop exit"); 501 502 /* NOTREACHED */ 503 return -1; 504 } 505 506 /* ARGSUSED0 */ 507 uint64_t 508 perfuse_get_ino(pu, opc) 509 struct puffs_usermount *pu; 510 puffs_cookie_t opc; 511 { 512 return PERFUSE_NODE_DATA(opc)->pnd_ino; 513 } 514 515 int 516 perfuse_unmount(pu) 517 struct puffs_usermount *pu; 518 { 519 struct perfuse_state *ps; 520 521 ps = puffs_getspecific(pu); 522 523 return unmount(ps->ps_target, MNT_FORCE); 524 } 525
Indexes created Fri Sep 26 08:10:20 GMT 2025