xref: /freebsd/sys/fs/fuse/fuse_internal.c (revision f4b37ed0f8b307b1f3f0f630ca725d68f1dff30d) 
1 /*
2  * Copyright (c) 2007-2009 Google Inc. and Amit Singh
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  * * Redistributions of source code must retain the above copyright
10  *   notice, this list of conditions and the following disclaimer.
11  * * Redistributions in binary form must reproduce the above
12  *   copyright notice, this list of conditions and the following disclaimer
13  *   in the documentation and/or other materials provided with the
14  *   distribution.
15  * * Neither the name of Google Inc. nor the names of its
16  *   contributors may be used to endorse or promote products derived from
17  *   this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  *
31  * Copyright (C) 2005 Csaba Henk.
32  * All rights reserved.
33  *
34  * Redistribution and use in source and binary forms, with or without
35  * modification, are permitted provided that the following conditions
36  * are met:
37  * 1. Redistributions of source code must retain the above copyright
38  *    notice, this list of conditions and the following disclaimer.
39  * 2. Redistributions in binary form must reproduce the above copyright
40  *    notice, this list of conditions and the following disclaimer in the
41  *    documentation and/or other materials provided with the distribution.
42  *
43  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
44  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
47  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53  * SUCH DAMAGE.
54  */
55 
56 #include <sys/cdefs.h>
57 __FBSDID("$FreeBSD$");
58 
59 #include <sys/types.h>
60 #include <sys/module.h>
61 #include <sys/systm.h>
62 #include <sys/errno.h>
63 #include <sys/param.h>
64 #include <sys/kernel.h>
65 #include <sys/conf.h>
66 #include <sys/uio.h>
67 #include <sys/malloc.h>
68 #include <sys/queue.h>
69 #include <sys/lock.h>
70 #include <sys/mutex.h>
71 #include <sys/sx.h>
72 #include <sys/proc.h>
73 #include <sys/mount.h>
74 #include <sys/vnode.h>
75 #include <sys/namei.h>
76 #include <sys/stat.h>
77 #include <sys/unistd.h>
78 #include <sys/filedesc.h>
79 #include <sys/file.h>
80 #include <sys/fcntl.h>
81 #include <sys/dirent.h>
82 #include <sys/bio.h>
83 #include <sys/buf.h>
84 #include <sys/sysctl.h>
85 #include <sys/priv.h>
86 
87 #include "fuse.h"
88 #include "fuse_file.h"
89 #include "fuse_internal.h"
90 #include "fuse_ipc.h"
91 #include "fuse_node.h"
92 #include "fuse_file.h"
93 #include "fuse_param.h"
94 
95 #define FUSE_DEBUG_MODULE INTERNAL
96 #include "fuse_debug.h"
97 
98 #ifdef ZERO_PAD_INCOMPLETE_BUFS
99 static int isbzero(void *buf, size_t len);
100 
101 #endif
102 
103 /* access */
104 
105 int
106 fuse_internal_access(struct vnode *vp,
107     mode_t mode,
108     struct fuse_access_param *facp,
109     struct thread *td,
110     struct ucred *cred)
111 {
112 	int err = 0;
113 	uint32_t mask = 0;
114 	int dataflags;
115 	int vtype;
116 	struct mount *mp;
117 	struct fuse_dispatcher fdi;
118 	struct fuse_access_in *fai;
119 	struct fuse_data *data;
120 
121 	/* NOT YET DONE */
122 	/*
123 	 * If this vnop gives you trouble, just return 0 here for a lazy
124 	 * kludge.
125 	 */
126 	/* return 0;*/
127 
128 	fuse_trace_printf_func();
129 
130 	mp = vnode_mount(vp);
131 	vtype = vnode_vtype(vp);
132 
133 	data = fuse_get_mpdata(mp);
134 	dataflags = data->dataflags;
135 
136 	if ((mode & VWRITE) && vfs_isrdonly(mp)) {
137 		return EACCES;
138 	}
139 	/* Unless explicitly permitted, deny everyone except the fs owner. */
140 	    if (vnode_isvroot(vp) && !(facp->facc_flags & FACCESS_NOCHECKSPY)) {
141 		if (!(dataflags & FSESS_DAEMON_CAN_SPY)) {
142 			int denied = fuse_match_cred(data->daemoncred,
143 			    cred);
144 
145 			if (denied) {
146 				return EPERM;
147 			}
148 		}
149 		facp->facc_flags |= FACCESS_NOCHECKSPY;
150 	}
151 	if (!(facp->facc_flags & FACCESS_DO_ACCESS)) {
152 		return 0;
153 	}
154 	if (((vtype == VREG) && (mode & VEXEC))) {
155 #ifdef NEED_MOUNT_ARGUMENT_FOR_THIS
156 		/* Let	 the kernel handle this through open / close heuristics.*/
157 		    return ENOTSUP;
158 #else
159 		    /* 	Let the kernel handle this. */
160 		    return 0;
161 #endif
162 	}
163 	if (!fsess_isimpl(mp, FUSE_ACCESS)) {
164 		/* Let the kernel handle this. */
165 		    return 0;
166 	}
167 	if (dataflags & FSESS_DEFAULT_PERMISSIONS) {
168 		/* Let the kernel handle this. */
169 		    return 0;
170 	}
171 	if ((mode & VADMIN) != 0) {
172 		err = priv_check_cred(cred, PRIV_VFS_ADMIN, 0);
173 		if (err) {
174 			return err;
175 		}
176 	}
177 	if ((mode & (VWRITE | VAPPEND | VADMIN)) != 0) {
178 		mask |= W_OK;
179 	}
180 	if ((mode & VREAD) != 0) {
181 		mask |= R_OK;
182 	}
183 	if ((mode & VEXEC) != 0) {
184 		mask |= X_OK;
185 	}
186 	bzero(&fdi, sizeof(fdi));
187 
188 	fdisp_init(&fdi, sizeof(*fai));
189 	fdisp_make_vp(&fdi, FUSE_ACCESS, vp, td, cred);
190 
191 	fai = fdi.indata;
192 	fai->mask = F_OK;
193 	fai->mask |= mask;
194 
195 	err = fdisp_wait_answ(&fdi);
196 	fdisp_destroy(&fdi);
197 
198 	if (err == ENOSYS) {
199 		fsess_set_notimpl(mp, FUSE_ACCESS);
200 		err = 0;
201 	}
202 	return err;
203 }
204 
205 /* fsync */
206 
207 int
208 fuse_internal_fsync_callback(struct fuse_ticket *tick, struct uio *uio)
209 {
210 	fuse_trace_printf_func();
211 
212 	if (tick->tk_aw_ohead.error == ENOSYS) {
213 		fsess_set_notimpl(tick->tk_data->mp, fticket_opcode(tick));
214 	}
215 	return 0;
216 }
217 
218 int
219 fuse_internal_fsync(struct vnode *vp,
220     struct thread *td,
221     struct ucred *cred,
222     struct fuse_filehandle *fufh)
223 {
224 	int op = FUSE_FSYNC;
225 	struct fuse_fsync_in *ffsi;
226 	struct fuse_dispatcher fdi;
227 
228 	fuse_trace_printf_func();
229 
230 	if (vnode_isdir(vp)) {
231 		op = FUSE_FSYNCDIR;
232 	}
233 	fdisp_init(&fdi, sizeof(*ffsi));
234 	fdisp_make_vp(&fdi, op, vp, td, cred);
235 	ffsi = fdi.indata;
236 	ffsi->fh = fufh->fh_id;
237 
238 	ffsi->fsync_flags = 1;		/* datasync */
239 
240 	fuse_insert_callback(fdi.tick, fuse_internal_fsync_callback);
241 	fuse_insert_message(fdi.tick);
242 
243 	fdisp_destroy(&fdi);
244 
245 	return 0;
246 
247 }
248 
249 /* readdir */
250 
251 int
252 fuse_internal_readdir(struct vnode *vp,
253     struct uio *uio,
254     struct fuse_filehandle *fufh,
255     struct fuse_iov *cookediov)
256 {
257 	int err = 0;
258 	struct fuse_dispatcher fdi;
259 	struct fuse_read_in *fri;
260 
261 	if (uio_resid(uio) == 0) {
262 		return 0;
263 	}
264 	fdisp_init(&fdi, 0);
265 
266 	/*
267 	 * Note that we DO NOT have a UIO_SYSSPACE here (so no need for p2p
268 	 * I/O).
269 	 */
270 
271 	while (uio_resid(uio) > 0) {
272 
273 		fdi.iosize = sizeof(*fri);
274 		fdisp_make_vp(&fdi, FUSE_READDIR, vp, NULL, NULL);
275 
276 		fri = fdi.indata;
277 		fri->fh = fufh->fh_id;
278 		fri->offset = uio_offset(uio);
279 		fri->size = min(uio_resid(uio), FUSE_DEFAULT_IOSIZE);
280 		/* mp->max_read */
281 
282 		    if ((err = fdisp_wait_answ(&fdi))) {
283 			break;
284 		}
285 		if ((err = fuse_internal_readdir_processdata(uio, fri->size, fdi.answ,
286 		    fdi.iosize, cookediov))) {
287 			break;
288 		}
289 	}
290 
291 	fdisp_destroy(&fdi);
292 	return ((err == -1) ? 0 : err);
293 }
294 
295 int
296 fuse_internal_readdir_processdata(struct uio *uio,
297     size_t reqsize,
298     void *buf,
299     size_t bufsize,
300     void *param)
301 {
302 	int err = 0;
303 	int cou = 0;
304 	int bytesavail;
305 	size_t freclen;
306 
307 	struct dirent *de;
308 	struct fuse_dirent *fudge;
309 	struct fuse_iov *cookediov = param;
310 
311 	if (bufsize < FUSE_NAME_OFFSET) {
312 		return -1;
313 	}
314 	for (;;) {
315 
316 		if (bufsize < FUSE_NAME_OFFSET) {
317 			err = -1;
318 			break;
319 		}
320 		fudge = (struct fuse_dirent *)buf;
321 		freclen = FUSE_DIRENT_SIZE(fudge);
322 
323 		cou++;
324 
325 		if (bufsize < freclen) {
326 			err = ((cou == 1) ? -1 : 0);
327 			break;
328 		}
329 #ifdef ZERO_PAD_INCOMPLETE_BUFS
330 		if (isbzero(buf, FUSE_NAME_OFFSET)) {
331 			err = -1;
332 			break;
333 		}
334 #endif
335 
336 		if (!fudge->namelen || fudge->namelen > MAXNAMLEN) {
337 			err = EINVAL;
338 			break;
339 		}
340 		bytesavail = GENERIC_DIRSIZ((struct pseudo_dirent *)
341 					    &fudge->namelen);
342 
343 		if (bytesavail > uio_resid(uio)) {
344 			err = -1;
345 			break;
346 		}
347 		fiov_refresh(cookediov);
348 		fiov_adjust(cookediov, bytesavail);
349 
350 		de = (struct dirent *)cookediov->base;
351 		de->d_fileno = fudge->ino;	/* XXX: truncation */
352 		de->d_reclen = bytesavail;
353 		de->d_type = fudge->type;
354 		de->d_namlen = fudge->namelen;
355 		memcpy((char *)cookediov->base + sizeof(struct dirent) -
356 		       MAXNAMLEN - 1,
357 		       (char *)buf + FUSE_NAME_OFFSET, fudge->namelen);
358 		((char *)cookediov->base)[bytesavail] = '\0';
359 
360 		err = uiomove(cookediov->base, cookediov->len, uio);
361 		if (err) {
362 			break;
363 		}
364 		buf = (char *)buf + freclen;
365 		bufsize -= freclen;
366 		uio_setoffset(uio, fudge->off);
367 	}
368 
369 	return err;
370 }
371 
372 /* remove */
373 
374 #define INVALIDATE_CACHED_VATTRS_UPON_UNLINK 1
375 int
376 fuse_internal_remove(struct vnode *dvp,
377     struct vnode *vp,
378     struct componentname *cnp,
379     enum fuse_opcode op)
380 {
381 	struct fuse_dispatcher fdi;
382 
383 	struct vattr *vap = VTOVA(vp);
384 
385 #if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
386 	int need_invalidate = 0;
387 	uint64_t target_nlink = 0;
388 
389 #endif
390 	int err = 0;
391 
392 	debug_printf("dvp=%p, cnp=%p, op=%d\n", vp, cnp, op);
393 
394 	fdisp_init(&fdi, cnp->cn_namelen + 1);
395 	fdisp_make_vp(&fdi, op, dvp, cnp->cn_thread, cnp->cn_cred);
396 
397 	memcpy(fdi.indata, cnp->cn_nameptr, cnp->cn_namelen);
398 	((char *)fdi.indata)[cnp->cn_namelen] = '\0';
399 
400 #if INVALIDATE_CACHED_VATTRS_UPON_UNLINK
401 	if (vap->va_nlink > 1) {
402 		need_invalidate = 1;
403 		target_nlink = vap->va_nlink;
404 	}
405 #endif
406 
407 	err = fdisp_wait_answ(&fdi);
408 	fdisp_destroy(&fdi);
409 	return err;
410 }
411 
412 /* rename */
413 
414 int
415 fuse_internal_rename(struct vnode *fdvp,
416     struct componentname *fcnp,
417     struct vnode *tdvp,
418     struct componentname *tcnp)
419 {
420 	struct fuse_dispatcher fdi;
421 	struct fuse_rename_in *fri;
422 	int err = 0;
423 
424 	fdisp_init(&fdi, sizeof(*fri) + fcnp->cn_namelen + tcnp->cn_namelen + 2);
425 	fdisp_make_vp(&fdi, FUSE_RENAME, fdvp, tcnp->cn_thread, tcnp->cn_cred);
426 
427 	fri = fdi.indata;
428 	fri->newdir = VTOI(tdvp);
429 	memcpy((char *)fdi.indata + sizeof(*fri), fcnp->cn_nameptr,
430 	    fcnp->cn_namelen);
431 	((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen] = '\0';
432 	memcpy((char *)fdi.indata + sizeof(*fri) + fcnp->cn_namelen + 1,
433 	    tcnp->cn_nameptr, tcnp->cn_namelen);
434 	((char *)fdi.indata)[sizeof(*fri) + fcnp->cn_namelen +
435 	    tcnp->cn_namelen + 1] = '\0';
436 
437 	err = fdisp_wait_answ(&fdi);
438 	fdisp_destroy(&fdi);
439 	return err;
440 }
441 
442 /* strategy */
443 
444 /* entity creation */
445 
446 void
447 fuse_internal_newentry_makerequest(struct mount *mp,
448     uint64_t dnid,
449     struct componentname *cnp,
450     enum fuse_opcode op,
451     void *buf,
452     size_t bufsize,
453     struct fuse_dispatcher *fdip)
454 {
455 	debug_printf("fdip=%p\n", fdip);
456 
457 	fdip->iosize = bufsize + cnp->cn_namelen + 1;
458 
459 	fdisp_make(fdip, op, mp, dnid, cnp->cn_thread, cnp->cn_cred);
460 	memcpy(fdip->indata, buf, bufsize);
461 	memcpy((char *)fdip->indata + bufsize, cnp->cn_nameptr, cnp->cn_namelen);
462 	((char *)fdip->indata)[bufsize + cnp->cn_namelen] = '\0';
463 }
464 
465 int
466 fuse_internal_newentry_core(struct vnode *dvp,
467     struct vnode **vpp,
468     struct componentname *cnp,
469     enum vtype vtyp,
470     struct fuse_dispatcher *fdip)
471 {
472 	int err = 0;
473 	struct fuse_entry_out *feo;
474 	struct mount *mp = vnode_mount(dvp);
475 
476 	if ((err = fdisp_wait_answ(fdip))) {
477 		return err;
478 	}
479 	feo = fdip->answ;
480 
481 	if ((err = fuse_internal_checkentry(feo, vtyp))) {
482 		return err;
483 	}
484 	err = fuse_vnode_get(mp, feo->nodeid, dvp, vpp, cnp, vtyp);
485 	if (err) {
486 		fuse_internal_forget_send(mp, cnp->cn_thread, cnp->cn_cred,
487 		    feo->nodeid, 1);
488 		return err;
489 	}
490 	cache_attrs(*vpp, feo);
491 
492 	return err;
493 }
494 
495 int
496 fuse_internal_newentry(struct vnode *dvp,
497     struct vnode **vpp,
498     struct componentname *cnp,
499     enum fuse_opcode op,
500     void *buf,
501     size_t bufsize,
502     enum vtype vtype)
503 {
504 	int err;
505 	struct fuse_dispatcher fdi;
506 	struct mount *mp = vnode_mount(dvp);
507 
508 	fdisp_init(&fdi, 0);
509 	fuse_internal_newentry_makerequest(mp, VTOI(dvp), cnp, op, buf,
510 	    bufsize, &fdi);
511 	err = fuse_internal_newentry_core(dvp, vpp, cnp, vtype, &fdi);
512 	fdisp_destroy(&fdi);
513 
514 	return err;
515 }
516 
517 /* entity destruction */
518 
519 int
520 fuse_internal_forget_callback(struct fuse_ticket *ftick, struct uio *uio)
521 {
522 	fuse_internal_forget_send(ftick->tk_data->mp, curthread, NULL,
523 	    ((struct fuse_in_header *)ftick->tk_ms_fiov.base)->nodeid, 1);
524 
525 	return 0;
526 }
527 
528 void
529 fuse_internal_forget_send(struct mount *mp,
530     struct thread *td,
531     struct ucred *cred,
532     uint64_t nodeid,
533     uint64_t nlookup)
534 {
535 
536 	struct fuse_dispatcher fdi;
537 	struct fuse_forget_in *ffi;
538 
539 	debug_printf("mp=%p, nodeid=%ju, nlookup=%ju\n",
540 	    mp, (uintmax_t)nodeid, (uintmax_t)nlookup);
541 
542 	/*
543          * KASSERT(nlookup > 0, ("zero-times forget for vp #%llu",
544          *         (long long unsigned) nodeid));
545          */
546 
547 	fdisp_init(&fdi, sizeof(*ffi));
548 	fdisp_make(&fdi, FUSE_FORGET, mp, nodeid, td, cred);
549 
550 	ffi = fdi.indata;
551 	ffi->nlookup = nlookup;
552 
553 	fuse_insert_message(fdi.tick);
554 	fdisp_destroy(&fdi);
555 }
556 
557 void
558 fuse_internal_vnode_disappear(struct vnode *vp)
559 {
560 	struct fuse_vnode_data *fvdat = VTOFUD(vp);
561 
562 	ASSERT_VOP_ELOCKED(vp, "fuse_internal_vnode_disappear");
563 	fvdat->flag |= FN_REVOKED;
564 	cache_purge(vp);
565 }
566 
567 /* fuse start/stop */
568 
569 int
570 fuse_internal_init_callback(struct fuse_ticket *tick, struct uio *uio)
571 {
572 	int err = 0;
573 	struct fuse_data *data = tick->tk_data;
574 	struct fuse_init_out *fiio;
575 
576 	if ((err = tick->tk_aw_ohead.error)) {
577 		goto out;
578 	}
579 	if ((err = fticket_pull(tick, uio))) {
580 		goto out;
581 	}
582 	fiio = fticket_resp(tick)->base;
583 
584 	/* XXX: Do we want to check anything further besides this? */
585 	if (fiio->major < 7) {
586 		debug_printf("userpace version too low\n");
587 		err = EPROTONOSUPPORT;
588 		goto out;
589 	}
590 	data->fuse_libabi_major = fiio->major;
591 	data->fuse_libabi_minor = fiio->minor;
592 
593 	if (fuse_libabi_geq(data, 7, 5)) {
594 		if (fticket_resp(tick)->len == sizeof(struct fuse_init_out)) {
595 			data->max_write = fiio->max_write;
596 		} else {
597 			err = EINVAL;
598 		}
599 	} else {
600 		/* Old fix values */
601 		data->max_write = 4096;
602 	}
603 
604 out:
605 	if (err) {
606 		fdata_set_dead(data);
607 	}
608 	FUSE_LOCK();
609 	data->dataflags |= FSESS_INITED;
610 	wakeup(&data->ticketer);
611 	FUSE_UNLOCK();
612 
613 	return 0;
614 }
615 
616 void
617 fuse_internal_send_init(struct fuse_data *data, struct thread *td)
618 {
619 	struct fuse_init_in *fiii;
620 	struct fuse_dispatcher fdi;
621 
622 	fdisp_init(&fdi, sizeof(*fiii));
623 	fdisp_make(&fdi, FUSE_INIT, data->mp, 0, td, NULL);
624 	fiii = fdi.indata;
625 	fiii->major = FUSE_KERNEL_VERSION;
626 	fiii->minor = FUSE_KERNEL_MINOR_VERSION;
627 	fiii->max_readahead = FUSE_DEFAULT_IOSIZE * 16;
628 	fiii->flags = 0;
629 
630 	fuse_insert_callback(fdi.tick, fuse_internal_init_callback);
631 	fuse_insert_message(fdi.tick);
632 	fdisp_destroy(&fdi);
633 }
634 
635 #ifdef ZERO_PAD_INCOMPLETE_BUFS
636 static int
637 isbzero(void *buf, size_t len)
638 {
639 	int i;
640 
641 	for (i = 0; i < len; i++) {
642 		if (((char *)buf)[i])
643 			return (0);
644 	}
645 
646 	return (1);
647 }
648 
649 #endif
650