xref: /freebsd/sys/fs/fdescfs/fdesc_vnops.c (revision 8655c70597b0e0918c82114b1186df5669b83eb6)
1 /*-
2  * Copyright (c) 1992, 1993
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software donated to Berkeley by
6  * Jan-Simon Pendry.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 4. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  *	@(#)fdesc_vnops.c	8.9 (Berkeley) 1/21/94
33  *
34  * $FreeBSD$
35  */
36 
37 /*
38  * /dev/fd Filesystem
39  */
40 
41 #include <sys/param.h>
42 #include <sys/systm.h>
43 #include <sys/conf.h>
44 #include <sys/dirent.h>
45 #include <sys/filedesc.h>
46 #include <sys/kernel.h>	/* boottime */
47 #include <sys/lock.h>
48 #include <sys/mutex.h>
49 #include <sys/malloc.h>
50 #include <sys/file.h>	/* Must come after sys/malloc.h */
51 #include <sys/mount.h>
52 #include <sys/namei.h>
53 #include <sys/proc.h>
54 #include <sys/stat.h>
55 #include <sys/vnode.h>
56 
57 #include <fs/fdescfs/fdesc.h>
58 
59 #define	NFDCACHE 4
60 #define FD_NHASH(ix) \
61 	(&fdhashtbl[(ix) & fdhash])
62 static LIST_HEAD(fdhashhead, fdescnode) *fdhashtbl;
63 static u_long fdhash;
64 
65 struct mtx fdesc_hashmtx;
66 
67 static vop_getattr_t	fdesc_getattr;
68 static vop_lookup_t	fdesc_lookup;
69 static vop_open_t	fdesc_open;
70 static vop_readdir_t	fdesc_readdir;
71 static vop_reclaim_t	fdesc_reclaim;
72 static vop_setattr_t	fdesc_setattr;
73 
74 static struct vop_vector fdesc_vnodeops = {
75 	.vop_default =		&default_vnodeops,
76 
77 	.vop_access =		VOP_NULL,
78 	.vop_getattr =		fdesc_getattr,
79 	.vop_lookup =		fdesc_lookup,
80 	.vop_open =		fdesc_open,
81 	.vop_pathconf =		vop_stdpathconf,
82 	.vop_readdir =		fdesc_readdir,
83 	.vop_reclaim =		fdesc_reclaim,
84 	.vop_setattr =		fdesc_setattr,
85 };
86 
87 static void fdesc_insmntque_dtr(struct vnode *, void *);
88 static void fdesc_remove_entry(struct fdescnode *);
89 
90 /*
91  * Initialise cache headers
92  */
93 int
94 fdesc_init(vfsp)
95 	struct vfsconf *vfsp;
96 {
97 
98 	mtx_init(&fdesc_hashmtx, "fdescfs_hash", NULL, MTX_DEF);
99 	fdhashtbl = hashinit(NFDCACHE, M_CACHE, &fdhash);
100 	return (0);
101 }
102 
103 /*
104  * Uninit ready for unload.
105  */
106 int
107 fdesc_uninit(vfsp)
108 	struct vfsconf *vfsp;
109 {
110 
111 	hashdestroy(fdhashtbl, M_CACHE, fdhash);
112 	mtx_destroy(&fdesc_hashmtx);
113 	return (0);
114 }
115 
116 /*
117  * If allocating vnode fails, call this.
118  */
119 static void
120 fdesc_insmntque_dtr(struct vnode *vp, void *arg)
121 {
122 
123 	vgone(vp);
124 	vput(vp);
125 }
126 
127 /*
128  * Remove an entry from the hash if it exists.
129  */
130 static void
131 fdesc_remove_entry(struct fdescnode *fd)
132 {
133 	struct fdhashhead *fc;
134 	struct fdescnode *fd2;
135 
136 	fc = FD_NHASH(fd->fd_ix);
137 	mtx_lock(&fdesc_hashmtx);
138 	LIST_FOREACH(fd2, fc, fd_hash) {
139 		if (fd == fd2) {
140 			LIST_REMOVE(fd, fd_hash);
141 			break;
142 		}
143 	}
144 	mtx_unlock(&fdesc_hashmtx);
145 }
146 
147 int
148 fdesc_allocvp(ftype, fd_fd, ix, mp, vpp, td)
149 	fdntype ftype;
150 	unsigned fd_fd;
151 	int ix;
152 	struct mount *mp;
153 	struct vnode **vpp;
154 	struct thread *td;
155 {
156 	struct fdescmount *fmp;
157 	struct fdhashhead *fc;
158 	struct fdescnode *fd, *fd2;
159 	struct vnode *vp, *vp2;
160 	int error = 0;
161 
162 	fc = FD_NHASH(ix);
163 loop:
164 	mtx_lock(&fdesc_hashmtx);
165 	/*
166 	 * If a forced unmount is progressing, we need to drop it. The flags are
167 	 * protected by the hashmtx.
168 	 */
169 	fmp = (struct fdescmount *)mp->mnt_data;
170 	if (fmp == NULL || fmp->flags & FMNT_UNMOUNTF) {
171 		mtx_unlock(&fdesc_hashmtx);
172 		return (-1);
173 	}
174 
175 	LIST_FOREACH(fd, fc, fd_hash) {
176 		if (fd->fd_ix == ix && fd->fd_vnode->v_mount == mp) {
177 			/* Get reference to vnode in case it's being free'd */
178 			vp = fd->fd_vnode;
179 			VI_LOCK(vp);
180 			mtx_unlock(&fdesc_hashmtx);
181 			if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td))
182 				goto loop;
183 			*vpp = vp;
184 			return (0);
185 		}
186 	}
187 	mtx_unlock(&fdesc_hashmtx);
188 
189 	fd = malloc(sizeof(struct fdescnode), M_TEMP, M_WAITOK);
190 
191 	error = getnewvnode("fdescfs", mp, &fdesc_vnodeops, &vp);
192 	if (error) {
193 		free(fd, M_TEMP);
194 		return (error);
195 	}
196 	vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
197 	vp->v_data = fd;
198 	fd->fd_vnode = vp;
199 	fd->fd_type = ftype;
200 	fd->fd_fd = fd_fd;
201 	fd->fd_ix = ix;
202 	error = insmntque1(vp, mp, fdesc_insmntque_dtr, NULL);
203 	if (error != 0) {
204 		*vpp = NULLVP;
205 		return (error);
206 	}
207 
208 	/* Make sure that someone didn't beat us when inserting the vnode. */
209 	mtx_lock(&fdesc_hashmtx);
210 	/*
211 	 * If a forced unmount is progressing, we need to drop it. The flags are
212 	 * protected by the hashmtx.
213 	 */
214 	fmp = (struct fdescmount *)mp->mnt_data;
215 	if (fmp == NULL || fmp->flags & FMNT_UNMOUNTF) {
216 		mtx_unlock(&fdesc_hashmtx);
217 		vgone(vp);
218 		vput(vp);
219 		*vpp = NULLVP;
220 		return (-1);
221 	}
222 
223 	LIST_FOREACH(fd2, fc, fd_hash) {
224 		if (fd2->fd_ix == ix && fd2->fd_vnode->v_mount == mp) {
225 			/* Get reference to vnode in case it's being free'd */
226 			vp2 = fd2->fd_vnode;
227 			VI_LOCK(vp2);
228 			mtx_unlock(&fdesc_hashmtx);
229 			error = vget(vp2, LK_EXCLUSIVE | LK_INTERLOCK, td);
230 			/* Someone beat us, dec use count and wait for reclaim */
231 			vgone(vp);
232 			vput(vp);
233 			/* If we didn't get it, return no vnode. */
234 			if (error)
235 				vp2 = NULLVP;
236 			*vpp = vp2;
237 			return (error);
238 		}
239 	}
240 
241 	/* If we came here, we can insert it safely. */
242 	LIST_INSERT_HEAD(fc, fd, fd_hash);
243 	mtx_unlock(&fdesc_hashmtx);
244 	*vpp = vp;
245 	return (0);
246 }
247 
248 /*
249  * vp is the current namei directory
250  * ndp is the name to locate in that directory...
251  */
252 static int
253 fdesc_lookup(ap)
254 	struct vop_lookup_args /* {
255 		struct vnode * a_dvp;
256 		struct vnode ** a_vpp;
257 		struct componentname * a_cnp;
258 	} */ *ap;
259 {
260 	struct vnode **vpp = ap->a_vpp;
261 	struct vnode *dvp = ap->a_dvp;
262 	struct componentname *cnp = ap->a_cnp;
263 	char *pname = cnp->cn_nameptr;
264 	struct thread *td = cnp->cn_thread;
265 	struct file *fp;
266 	int nlen = cnp->cn_namelen;
267 	u_int fd;
268 	int error;
269 	struct vnode *fvp;
270 
271 	if ((cnp->cn_flags & ISLASTCN) &&
272 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
273 		error = EROFS;
274 		goto bad;
275 	}
276 
277 	if (cnp->cn_namelen == 1 && *pname == '.') {
278 		*vpp = dvp;
279 		VREF(dvp);
280 		return (0);
281 	}
282 
283 	if (VTOFDESC(dvp)->fd_type != Froot) {
284 		error = ENOTDIR;
285 		goto bad;
286 	}
287 
288 	fd = 0;
289 	/* the only time a leading 0 is acceptable is if it's "0" */
290 	if (*pname == '0' && nlen != 1) {
291 		error = ENOENT;
292 		goto bad;
293 	}
294 	while (nlen--) {
295 		if (*pname < '0' || *pname > '9') {
296 			error = ENOENT;
297 			goto bad;
298 		}
299 		fd = 10 * fd + *pname++ - '0';
300 	}
301 
302 	if ((error = fget(td, fd, &fp)) != 0)
303 		goto bad;
304 
305 	/* Check if we're looking up ourselves. */
306 	if (VTOFDESC(dvp)->fd_ix == FD_DESC + fd) {
307 		/*
308 		 * In case we're holding the last reference to the file, the dvp
309 		 * will be re-acquired.
310 		 */
311 		vhold(dvp);
312 		VOP_UNLOCK(dvp, 0);
313 		fdrop(fp, td);
314 
315 		/* Re-aquire the lock afterwards. */
316 		vn_lock(dvp, LK_RETRY | LK_EXCLUSIVE);
317 		vdrop(dvp);
318 		fvp = dvp;
319 	} else {
320 		/*
321 		 * Unlock our root node (dvp) when doing this, since we might
322 		 * deadlock since the vnode might be locked by another thread
323 		 * and the root vnode lock will be obtained afterwards (in case
324 		 * we're looking up the fd of the root vnode), which will be the
325 		 * opposite lock order. Vhold the root vnode first so we don't
326 		 * loose it.
327 		 */
328 		vhold(dvp);
329 		VOP_UNLOCK(dvp, 0);
330 		error = fdesc_allocvp(Fdesc, fd, FD_DESC + fd, dvp->v_mount,
331 		    &fvp, td);
332 		fdrop(fp, td);
333 		/*
334 		 * The root vnode must be locked last to prevent deadlock condition.
335 		 */
336 		vn_lock(dvp, LK_RETRY | LK_EXCLUSIVE);
337 		vdrop(dvp);
338 	}
339 
340 	if (error)
341 		goto bad;
342 	*vpp = fvp;
343 	return (0);
344 
345 bad:
346 	*vpp = NULL;
347 	return (error);
348 }
349 
350 static int
351 fdesc_open(ap)
352 	struct vop_open_args /* {
353 		struct vnode *a_vp;
354 		int  a_mode;
355 		struct ucred *a_cred;
356 		struct thread *a_td;
357 	} */ *ap;
358 {
359 	struct vnode *vp = ap->a_vp;
360 
361 	if (VTOFDESC(vp)->fd_type == Froot)
362 		return (0);
363 
364 	/*
365 	 * XXX Kludge: set td->td_proc->p_dupfd to contain the value of the the file
366 	 * descriptor being sought for duplication. The error return ensures
367 	 * that the vnode for this device will be released by vn_open. Open
368 	 * will detect this special error and take the actions in dupfdopen.
369 	 * Other callers of vn_open or VOP_OPEN will simply report the
370 	 * error.
371 	 */
372 	ap->a_td->td_dupfd = VTOFDESC(vp)->fd_fd;	/* XXX */
373 	return (ENODEV);
374 }
375 
376 static int
377 fdesc_getattr(ap)
378 	struct vop_getattr_args /* {
379 		struct vnode *a_vp;
380 		struct vattr *a_vap;
381 		struct ucred *a_cred;
382 	} */ *ap;
383 {
384 	struct vnode *vp = ap->a_vp;
385 	struct vattr *vap = ap->a_vap;
386 	struct thread *td = curthread;
387 	struct file *fp;
388 	struct stat stb;
389 	u_int fd;
390 	int error = 0;
391 
392 	switch (VTOFDESC(vp)->fd_type) {
393 	case Froot:
394 		vap->va_mode = S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH;
395 		vap->va_type = VDIR;
396 		vap->va_nlink = 2;
397 		vap->va_size = DEV_BSIZE;
398 		vap->va_fileid = VTOFDESC(vp)->fd_ix;
399 		vap->va_uid = 0;
400 		vap->va_gid = 0;
401 		vap->va_blocksize = DEV_BSIZE;
402 		vap->va_atime.tv_sec = boottime.tv_sec;
403 		vap->va_atime.tv_nsec = 0;
404 		vap->va_mtime = vap->va_atime;
405 		vap->va_ctime = vap->va_mtime;
406 		vap->va_gen = 0;
407 		vap->va_flags = 0;
408 		vap->va_rdev = NODEV;
409 		vap->va_bytes = 0;
410 		vap->va_filerev = 0;
411 		break;
412 
413 	case Fdesc:
414 		fd = VTOFDESC(vp)->fd_fd;
415 
416 		if ((error = fget(td, fd, &fp)) != 0)
417 			return (error);
418 
419 		bzero(&stb, sizeof(stb));
420 		error = fo_stat(fp, &stb, td->td_ucred, td);
421 		fdrop(fp, td);
422 		if (error == 0) {
423 			vap->va_type = IFTOVT(stb.st_mode);
424 			vap->va_mode = stb.st_mode;
425 			if (vap->va_type == VDIR)
426 				vap->va_mode &= ~(S_IRUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH);
427 			vap->va_nlink = 1;
428 			vap->va_flags = 0;
429 			vap->va_bytes = stb.st_blocks * stb.st_blksize;
430 			vap->va_fileid = VTOFDESC(vp)->fd_ix;
431 			vap->va_size = stb.st_size;
432 			vap->va_blocksize = stb.st_blksize;
433 			vap->va_rdev = stb.st_rdev;
434 
435 			/*
436 			 * If no time data is provided, use the current time.
437 			 */
438 			if (stb.st_atimespec.tv_sec == 0 &&
439 			    stb.st_atimespec.tv_nsec == 0)
440 				nanotime(&stb.st_atimespec);
441 
442 			if (stb.st_ctimespec.tv_sec == 0 &&
443 			    stb.st_ctimespec.tv_nsec == 0)
444 				nanotime(&stb.st_ctimespec);
445 
446 			if (stb.st_mtimespec.tv_sec == 0 &&
447 			    stb.st_mtimespec.tv_nsec == 0)
448 				nanotime(&stb.st_mtimespec);
449 
450 			vap->va_atime = stb.st_atimespec;
451 			vap->va_mtime = stb.st_mtimespec;
452 			vap->va_ctime = stb.st_ctimespec;
453 			vap->va_uid = stb.st_uid;
454 			vap->va_gid = stb.st_gid;
455 			vap->va_gen = 0;
456 			vap->va_filerev = 0;
457 		}
458 		break;
459 
460 	default:
461 		panic("fdesc_getattr");
462 		break;
463 	}
464 
465 	if (error == 0)
466 		vp->v_type = vap->va_type;
467 	return (error);
468 }
469 
470 static int
471 fdesc_setattr(ap)
472 	struct vop_setattr_args /* {
473 		struct vnode *a_vp;
474 		struct vattr *a_vap;
475 		struct ucred *a_cred;
476 	} */ *ap;
477 {
478 	struct vattr *vap = ap->a_vap;
479 	struct vnode *vp;
480 	struct mount *mp;
481 	struct file *fp;
482 	struct thread *td = curthread;
483 	unsigned fd;
484 	int error;
485 
486 	/*
487 	 * Can't mess with the root vnode
488 	 */
489 	if (VTOFDESC(ap->a_vp)->fd_type == Froot)
490 		return (EACCES);
491 
492 	fd = VTOFDESC(ap->a_vp)->fd_fd;
493 
494 	/*
495 	 * Allow setattr where there is an underlying vnode.
496 	 */
497 	error = getvnode(td->td_proc->p_fd, fd, &fp);
498 	if (error) {
499 		/*
500 		 * getvnode() returns EINVAL if the file descriptor is not
501 		 * backed by a vnode.  Silently drop all changes except
502 		 * chflags(2) in this case.
503 		 */
504 		if (error == EINVAL) {
505 			if (vap->va_flags != VNOVAL)
506 				error = EOPNOTSUPP;
507 			else
508 				error = 0;
509 		}
510 		return (error);
511 	}
512 	vp = fp->f_vnode;
513 	if ((error = vn_start_write(vp, &mp, V_WAIT | PCATCH)) == 0) {
514 		vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
515 		error = VOP_SETATTR(vp, ap->a_vap, ap->a_cred);
516 		VOP_UNLOCK(vp, 0);
517 		vn_finished_write(mp);
518 	}
519 	fdrop(fp, td);
520 	return (error);
521 }
522 
523 #define UIO_MX 16
524 
525 static int
526 fdesc_readdir(ap)
527 	struct vop_readdir_args /* {
528 		struct vnode *a_vp;
529 		struct uio *a_uio;
530 		struct ucred *a_cred;
531 		int *a_eofflag;
532 		u_long *a_cookies;
533 		int a_ncookies;
534 	} */ *ap;
535 {
536 	struct uio *uio = ap->a_uio;
537 	struct filedesc *fdp;
538 	struct dirent d;
539 	struct dirent *dp = &d;
540 	int error, i, off, fcnt;
541 
542 	/*
543 	 * We don't allow exporting fdesc mounts, and currently local
544 	 * requests do not need cookies.
545 	 */
546 	if (ap->a_ncookies)
547 		panic("fdesc_readdir: not hungry");
548 
549 	if (VTOFDESC(ap->a_vp)->fd_type != Froot)
550 		panic("fdesc_readdir: not dir");
551 
552 	off = (int)uio->uio_offset;
553 	if (off != uio->uio_offset || off < 0 || (u_int)off % UIO_MX != 0 ||
554 	    uio->uio_resid < UIO_MX)
555 		return (EINVAL);
556 	i = (u_int)off / UIO_MX;
557 	fdp = uio->uio_td->td_proc->p_fd;
558 	error = 0;
559 
560 	fcnt = i - 2;		/* The first two nodes are `.' and `..' */
561 
562 	FILEDESC_SLOCK(fdp);
563 	while (i < fdp->fd_nfiles + 2 && uio->uio_resid >= UIO_MX) {
564 		switch (i) {
565 		case 0:	/* `.' */
566 		case 1: /* `..' */
567 			bzero((caddr_t)dp, UIO_MX);
568 
569 			dp->d_fileno = i + FD_ROOT;
570 			dp->d_namlen = i + 1;
571 			dp->d_reclen = UIO_MX;
572 			bcopy("..", dp->d_name, dp->d_namlen);
573 			dp->d_name[i + 1] = '\0';
574 			dp->d_type = DT_DIR;
575 			break;
576 		default:
577 			if (fdp->fd_ofiles[fcnt] == NULL) {
578 				FILEDESC_SUNLOCK(fdp);
579 				goto done;
580 			}
581 
582 			bzero((caddr_t) dp, UIO_MX);
583 			dp->d_namlen = sprintf(dp->d_name, "%d", fcnt);
584 			dp->d_reclen = UIO_MX;
585 			dp->d_type = DT_UNKNOWN;
586 			dp->d_fileno = i + FD_DESC;
587 			break;
588 		}
589 		/*
590 		 * And ship to userland
591 		 */
592 		FILEDESC_SUNLOCK(fdp);
593 		error = uiomove(dp, UIO_MX, uio);
594 		if (error)
595 			goto done;
596 		FILEDESC_SLOCK(fdp);
597 		i++;
598 		fcnt++;
599 	}
600 	FILEDESC_SUNLOCK(fdp);
601 
602 done:
603 	uio->uio_offset = i * UIO_MX;
604 	return (error);
605 }
606 
607 static int
608 fdesc_reclaim(ap)
609 	struct vop_reclaim_args /* {
610 		struct vnode *a_vp;
611 	} */ *ap;
612 {
613 	struct vnode *vp;
614 	struct fdescnode *fd;
615 
616  	vp = ap->a_vp;
617  	fd = VTOFDESC(vp);
618 	fdesc_remove_entry(fd);
619 	free(vp->v_data, M_TEMP);
620 	vp->v_data = NULL;
621 	return (0);
622 }
623