tmpfs_vnops.c revision 1.64 1 /* $NetBSD: tmpfs_vnops.c,v 1.64 2009/10/17 22:20:56 njoly Exp $ */
2
3 /*
4 * Copyright (c) 2005, 2006, 2007 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Julio M. Merino Vidal, developed as part of Google's Summer of Code
9 * 2005 program.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 /*
34 * tmpfs vnode interface.
35 */
36
37 #include <sys/cdefs.h>
38 __KERNEL_RCSID(0, "$NetBSD: tmpfs_vnops.c,v 1.64 2009/10/17 22:20:56 njoly Exp $");
39
40 #include <sys/param.h>
41 #include <sys/dirent.h>
42 #include <sys/fcntl.h>
43 #include <sys/event.h>
44 #include <sys/malloc.h>
45 #include <sys/namei.h>
46 #include <sys/proc.h>
47 #include <sys/stat.h>
48 #include <sys/uio.h>
49 #include <sys/unistd.h>
50 #include <sys/vnode.h>
51 #include <sys/lockf.h>
52 #include <sys/kauth.h>
53
54 #include <uvm/uvm.h>
55
56 #include <miscfs/fifofs/fifo.h>
57 #include <miscfs/genfs/genfs.h>
58 #include <fs/tmpfs/tmpfs_vnops.h>
59 #include <fs/tmpfs/tmpfs.h>
60
61 /* --------------------------------------------------------------------- */
62
63 /*
64 * vnode operations vector used for files stored in a tmpfs file system.
65 */
66 int (**tmpfs_vnodeop_p)(void *);
67 const struct vnodeopv_entry_desc tmpfs_vnodeop_entries[] = {
68 { &vop_default_desc, vn_default_error },
69 { &vop_lookup_desc, tmpfs_lookup },
70 { &vop_create_desc, tmpfs_create },
71 { &vop_mknod_desc, tmpfs_mknod },
72 { &vop_open_desc, tmpfs_open },
73 { &vop_close_desc, tmpfs_close },
74 { &vop_access_desc, tmpfs_access },
75 { &vop_getattr_desc, tmpfs_getattr },
76 { &vop_setattr_desc, tmpfs_setattr },
77 { &vop_read_desc, tmpfs_read },
78 { &vop_write_desc, tmpfs_write },
79 { &vop_ioctl_desc, tmpfs_ioctl },
80 { &vop_fcntl_desc, tmpfs_fcntl },
81 { &vop_poll_desc, tmpfs_poll },
82 { &vop_kqfilter_desc, tmpfs_kqfilter },
83 { &vop_revoke_desc, tmpfs_revoke },
84 { &vop_mmap_desc, tmpfs_mmap },
85 { &vop_fsync_desc, tmpfs_fsync },
86 { &vop_seek_desc, tmpfs_seek },
87 { &vop_remove_desc, tmpfs_remove },
88 { &vop_link_desc, tmpfs_link },
89 { &vop_rename_desc, tmpfs_rename },
90 { &vop_mkdir_desc, tmpfs_mkdir },
91 { &vop_rmdir_desc, tmpfs_rmdir },
92 { &vop_symlink_desc, tmpfs_symlink },
93 { &vop_readdir_desc, tmpfs_readdir },
94 { &vop_readlink_desc, tmpfs_readlink },
95 { &vop_abortop_desc, tmpfs_abortop },
96 { &vop_inactive_desc, tmpfs_inactive },
97 { &vop_reclaim_desc, tmpfs_reclaim },
98 { &vop_lock_desc, tmpfs_lock },
99 { &vop_unlock_desc, tmpfs_unlock },
100 { &vop_bmap_desc, tmpfs_bmap },
101 { &vop_strategy_desc, tmpfs_strategy },
102 { &vop_print_desc, tmpfs_print },
103 { &vop_pathconf_desc, tmpfs_pathconf },
104 { &vop_islocked_desc, tmpfs_islocked },
105 { &vop_advlock_desc, tmpfs_advlock },
106 { &vop_bwrite_desc, tmpfs_bwrite },
107 { &vop_getpages_desc, tmpfs_getpages },
108 { &vop_putpages_desc, tmpfs_putpages },
109 { NULL, NULL }
110 };
111 const struct vnodeopv_desc tmpfs_vnodeop_opv_desc =
112 { &tmpfs_vnodeop_p, tmpfs_vnodeop_entries };
113
114 /* --------------------------------------------------------------------- */
115
116 int
117 tmpfs_lookup(void *v)
118 {
119 struct vnode *dvp = ((struct vop_lookup_args *)v)->a_dvp;
120 struct vnode **vpp = ((struct vop_lookup_args *)v)->a_vpp;
121 struct componentname *cnp = ((struct vop_lookup_args *)v)->a_cnp;
122
123 int error;
124 struct tmpfs_dirent *de;
125 struct tmpfs_node *dnode;
126
127 KASSERT(VOP_ISLOCKED(dvp));
128
129 dnode = VP_TO_TMPFS_DIR(dvp);
130 *vpp = NULL;
131
132 /* Check accessibility of requested node as a first step. */
133 error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred);
134 if (error != 0)
135 goto out;
136
137 /* If requesting the last path component on a read-only file system
138 * with a write operation, deny it. */
139 if ((cnp->cn_flags & ISLASTCN) &&
140 (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
141 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
142 error = EROFS;
143 goto out;
144 }
145
146 /* Avoid doing a linear scan of the directory if the requested
147 * directory/name couple is already in the cache. */
148 error = cache_lookup(dvp, vpp, cnp);
149 if (error >= 0)
150 goto out;
151
152 /* We cannot be requesting the parent directory of the root node. */
153 KASSERT(IMPLIES(dnode->tn_type == VDIR &&
154 dnode->tn_spec.tn_dir.tn_parent == dnode,
155 !(cnp->cn_flags & ISDOTDOT)));
156
157 if (cnp->cn_flags & ISDOTDOT) {
158 VOP_UNLOCK(dvp, 0);
159
160 /* Allocate a new vnode on the matching entry. */
161 error = tmpfs_alloc_vp(dvp->v_mount,
162 dnode->tn_spec.tn_dir.tn_parent, vpp);
163
164 vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY);
165 } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
166 VREF(dvp);
167 *vpp = dvp;
168 error = 0;
169 } else {
170 de = tmpfs_dir_lookup(dnode, cnp);
171 if (de == NULL) {
172 /* The entry was not found in the directory.
173 * This is OK iff we are creating or renaming an
174 * entry and are working on the last component of
175 * the path name. */
176 if ((cnp->cn_flags & ISLASTCN) &&
177 (cnp->cn_nameiop == CREATE || \
178 cnp->cn_nameiop == RENAME)) {
179 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
180 if (error != 0)
181 goto out;
182
183 /* Keep the component name in the buffer for
184 * future uses. */
185 cnp->cn_flags |= SAVENAME;
186
187 error = EJUSTRETURN;
188 } else
189 error = ENOENT;
190 } else {
191 struct tmpfs_node *tnode;
192
193 /* The entry was found, so get its associated
194 * tmpfs_node. */
195 tnode = de->td_node;
196
197 /* If we are not at the last path component and
198 * found a non-directory or non-link entry (which
199 * may itself be pointing to a directory), raise
200 * an error. */
201 if ((tnode->tn_type != VDIR &&
202 tnode->tn_type != VLNK) &&
203 !(cnp->cn_flags & ISLASTCN)) {
204 error = ENOTDIR;
205 goto out;
206 }
207
208 /* Check permissions */
209 if ((cnp->cn_flags & ISLASTCN) &&
210 (cnp->cn_nameiop == DELETE ||
211 cnp->cn_nameiop == RENAME)) {
212 kauth_action_t action = 0;
213
214 /* This is the file-system's decision. */
215 if ((dnode->tn_mode & S_ISTXT) != 0 &&
216 kauth_cred_geteuid(cnp->cn_cred) != dnode->tn_uid &&
217 kauth_cred_geteuid(cnp->cn_cred) != tnode->tn_uid)
218 error = EPERM;
219 else
220 error = 0;
221
222 /* Only bother if we're not already failing it. */
223 if (!error) {
224 error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred);
225 }
226
227 if (cnp->cn_nameiop == DELETE)
228 action |= KAUTH_VNODE_DELETE;
229 else /* if (cnp->cn_nameiop == RENAME) */
230 action |= KAUTH_VNODE_RENAME;
231
232 error = kauth_authorize_vnode(cnp->cn_cred,
233 action, *vpp, dvp, error);
234 if (error != 0)
235 goto out;
236
237 cnp->cn_flags |= SAVENAME;
238 } else
239 de = NULL;
240
241 /* Allocate a new vnode on the matching entry. */
242 error = tmpfs_alloc_vp(dvp->v_mount, tnode, vpp);
243 }
244 }
245
246 /* Store the result of this lookup in the cache. Avoid this if the
247 * request was for creation, as it does not improve timings on
248 * emprical tests. */
249 if ((cnp->cn_flags & MAKEENTRY) && cnp->cn_nameiop != CREATE &&
250 (cnp->cn_flags & ISDOTDOT) == 0)
251 cache_enter(dvp, *vpp, cnp);
252
253 out:
254 /* If there were no errors, *vpp cannot be null and it must be
255 * locked. */
256 KASSERT(IFF(error == 0, *vpp != NULL && VOP_ISLOCKED(*vpp)));
257
258 /* dvp must always be locked. */
259 KASSERT(VOP_ISLOCKED(dvp));
260
261 return error;
262 }
263
264 /* --------------------------------------------------------------------- */
265
266 int
267 tmpfs_create(void *v)
268 {
269 struct vnode *dvp = ((struct vop_create_args *)v)->a_dvp;
270 struct vnode **vpp = ((struct vop_create_args *)v)->a_vpp;
271 struct componentname *cnp = ((struct vop_create_args *)v)->a_cnp;
272 struct vattr *vap = ((struct vop_create_args *)v)->a_vap;
273
274 KASSERT(vap->va_type == VREG || vap->va_type == VSOCK);
275
276 return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
277 }
278 /* --------------------------------------------------------------------- */
279
280 int
281 tmpfs_mknod(void *v)
282 {
283 struct vnode *dvp = ((struct vop_mknod_args *)v)->a_dvp;
284 struct vnode **vpp = ((struct vop_mknod_args *)v)->a_vpp;
285 struct componentname *cnp = ((struct vop_mknod_args *)v)->a_cnp;
286 struct vattr *vap = ((struct vop_mknod_args *)v)->a_vap;
287
288 if (vap->va_type != VBLK && vap->va_type != VCHR &&
289 vap->va_type != VFIFO) {
290 vput(dvp);
291 return EINVAL;
292 }
293
294 return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
295 }
296
297 /* --------------------------------------------------------------------- */
298
299 int
300 tmpfs_open(void *v)
301 {
302 struct vnode *vp = ((struct vop_open_args *)v)->a_vp;
303 int mode = ((struct vop_open_args *)v)->a_mode;
304
305 int error;
306 struct tmpfs_node *node;
307
308 KASSERT(VOP_ISLOCKED(vp));
309
310 node = VP_TO_TMPFS_NODE(vp);
311
312 /* The file is still active but all its names have been removed
313 * (e.g. by a "rmdir $(pwd)"). It cannot be opened any more as
314 * it is about to die. */
315 if (node->tn_links < 1) {
316 error = ENOENT;
317 goto out;
318 }
319
320 /* If the file is marked append-only, deny write requests. */
321 if (node->tn_flags & APPEND && (mode & (FWRITE | O_APPEND)) == FWRITE)
322 error = EPERM;
323 else
324 error = 0;
325
326 out:
327 KASSERT(VOP_ISLOCKED(vp));
328
329 return error;
330 }
331
332 /* --------------------------------------------------------------------- */
333
334 int
335 tmpfs_close(void *v)
336 {
337 struct vnode *vp = ((struct vop_close_args *)v)->a_vp;
338
339 struct tmpfs_node *node;
340
341 KASSERT(VOP_ISLOCKED(vp));
342
343 node = VP_TO_TMPFS_NODE(vp);
344
345 if (node->tn_links > 0) {
346 /* Update node times. No need to do it if the node has
347 * been deleted, because it will vanish after we return. */
348 tmpfs_update(vp, NULL, NULL, NULL, UPDATE_CLOSE);
349 }
350
351 return 0;
352 }
353
354 /* --------------------------------------------------------------------- */
355
356 static int
357 tmpfs_check_possible(struct vnode *vp, struct tmpfs_node *node, mode_t mode)
358 {
359 int error = 0;
360
361 switch (vp->v_type) {
362 case VDIR:
363 /* FALLTHROUGH */
364 case VLNK:
365 /* FALLTHROUGH */
366 case VREG:
367 if (mode & VWRITE && vp->v_mount->mnt_flag & MNT_RDONLY) {
368 error = EROFS;
369 goto out;
370 }
371 break;
372
373 case VBLK:
374 /* FALLTHROUGH */
375 case VCHR:
376 /* FALLTHROUGH */
377 case VSOCK:
378 /* FALLTHROUGH */
379 case VFIFO:
380 break;
381
382 default:
383 error = EINVAL;
384 goto out;
385 }
386
387 if (mode & VWRITE && node->tn_flags & IMMUTABLE) {
388 error = EPERM;
389 goto out;
390 }
391
392 out:
393 return error;
394 }
395
396 static int
397 tmpfs_check_permitted(struct vnode *vp, struct tmpfs_node *node, mode_t mode,
398 kauth_cred_t cred)
399 {
400
401 return genfs_can_access(vp->v_type, node->tn_mode, node->tn_uid,
402 node->tn_gid, mode, cred);
403 }
404
405 int
406 tmpfs_access(void *v)
407 {
408 struct vnode *vp = ((struct vop_access_args *)v)->a_vp;
409 int mode = ((struct vop_access_args *)v)->a_mode;
410 kauth_cred_t cred = ((struct vop_access_args *)v)->a_cred;
411
412 int error;
413 struct tmpfs_node *node;
414
415 KASSERT(VOP_ISLOCKED(vp));
416
417 node = VP_TO_TMPFS_NODE(vp);
418
419 error = tmpfs_check_possible(vp, node, mode);
420 if (error)
421 goto out;
422
423 error = tmpfs_check_permitted(vp, node, mode, cred);
424
425 error = kauth_authorize_vnode(cred, kauth_mode_to_action(mode), vp,
426 NULL, error);
427
428 out:
429 KASSERT(VOP_ISLOCKED(vp));
430
431 return error;
432 }
433
434 /* --------------------------------------------------------------------- */
435
436 int
437 tmpfs_getattr(void *v)
438 {
439 struct vnode *vp = ((struct vop_getattr_args *)v)->a_vp;
440 struct vattr *vap = ((struct vop_getattr_args *)v)->a_vap;
441
442 struct tmpfs_node *node;
443
444 node = VP_TO_TMPFS_NODE(vp);
445
446 VATTR_NULL(vap);
447
448 tmpfs_itimes(vp, NULL, NULL, NULL);
449
450 vap->va_type = vp->v_type;
451 vap->va_mode = node->tn_mode;
452 vap->va_nlink = node->tn_links;
453 vap->va_uid = node->tn_uid;
454 vap->va_gid = node->tn_gid;
455 vap->va_fsid = vp->v_mount->mnt_stat.f_fsidx.__fsid_val[0];
456 vap->va_fileid = node->tn_id;
457 vap->va_size = node->tn_size;
458 vap->va_blocksize = PAGE_SIZE;
459 vap->va_atime = node->tn_atime;
460 vap->va_mtime = node->tn_mtime;
461 vap->va_ctime = node->tn_ctime;
462 vap->va_birthtime = node->tn_birthtime;
463 vap->va_gen = node->tn_gen;
464 vap->va_flags = node->tn_flags;
465 vap->va_rdev = (vp->v_type == VBLK || vp->v_type == VCHR) ?
466 node->tn_spec.tn_dev.tn_rdev : VNOVAL;
467 vap->va_bytes = round_page(node->tn_size);
468 vap->va_filerev = VNOVAL;
469 vap->va_vaflags = 0;
470 vap->va_spare = VNOVAL; /* XXX */
471
472 return 0;
473 }
474
475 /* --------------------------------------------------------------------- */
476
477 #define GOODTIME(tv) ((tv)->tv_sec != VNOVAL || (tv)->tv_nsec != VNOVAL)
478 /* XXX Should this operation be atomic? I think it should, but code in
479 * XXX other places (e.g., ufs) doesn't seem to be... */
480 int
481 tmpfs_setattr(void *v)
482 {
483 struct vnode *vp = ((struct vop_setattr_args *)v)->a_vp;
484 struct vattr *vap = ((struct vop_setattr_args *)v)->a_vap;
485 kauth_cred_t cred = ((struct vop_setattr_args *)v)->a_cred;
486 struct lwp *l = curlwp;
487
488 int error;
489
490 KASSERT(VOP_ISLOCKED(vp));
491
492 error = 0;
493
494 /* Abort if any unsettable attribute is given. */
495 if (vap->va_type != VNON ||
496 vap->va_nlink != VNOVAL ||
497 vap->va_fsid != VNOVAL ||
498 vap->va_fileid != VNOVAL ||
499 vap->va_blocksize != VNOVAL ||
500 GOODTIME(&vap->va_ctime) ||
501 vap->va_gen != VNOVAL ||
502 vap->va_rdev != VNOVAL ||
503 vap->va_bytes != VNOVAL)
504 error = EINVAL;
505
506 if (error == 0 && (vap->va_flags != VNOVAL))
507 error = tmpfs_chflags(vp, vap->va_flags, cred, l);
508
509 if (error == 0 && (vap->va_size != VNOVAL))
510 error = tmpfs_chsize(vp, vap->va_size, cred, l);
511
512 if (error == 0 && (vap->va_uid != VNOVAL || vap->va_gid != VNOVAL))
513 error = tmpfs_chown(vp, vap->va_uid, vap->va_gid, cred, l);
514
515 if (error == 0 && (vap->va_mode != VNOVAL))
516 error = tmpfs_chmod(vp, vap->va_mode, cred, l);
517
518 if (error == 0 && (GOODTIME(&vap->va_atime) || GOODTIME(&vap->va_mtime)
519 || GOODTIME(&vap->va_birthtime)))
520 if ((error = tmpfs_chtimes(vp, &vap->va_atime, &vap->va_mtime,
521 &vap->va_birthtime, vap->va_vaflags, cred, l)) == 0)
522 return 0;
523
524 /* Update the node times. We give preference to the error codes
525 * generated by this function rather than the ones that may arise
526 * from tmpfs_update. */
527 tmpfs_update(vp, NULL, NULL, NULL, 0);
528
529 KASSERT(VOP_ISLOCKED(vp));
530
531 return error;
532 }
533
534 /* --------------------------------------------------------------------- */
535
536 int
537 tmpfs_read(void *v)
538 {
539 struct vnode *vp = ((struct vop_read_args *)v)->a_vp;
540 struct uio *uio = ((struct vop_read_args *)v)->a_uio;
541 int ioflag = ((struct vop_read_args *)v)->a_ioflag;
542
543 int error;
544 struct tmpfs_node *node;
545 struct uvm_object *uobj;
546
547 KASSERT(VOP_ISLOCKED(vp));
548
549 node = VP_TO_TMPFS_NODE(vp);
550
551 if (vp->v_type != VREG) {
552 error = EISDIR;
553 goto out;
554 }
555
556 if (uio->uio_offset < 0) {
557 error = EINVAL;
558 goto out;
559 }
560
561 node->tn_status |= TMPFS_NODE_ACCESSED;
562
563 uobj = node->tn_spec.tn_reg.tn_aobj;
564 error = 0;
565 while (error == 0 && uio->uio_resid > 0) {
566 vsize_t len;
567
568 if (node->tn_size <= uio->uio_offset)
569 break;
570
571 len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid);
572 if (len == 0)
573 break;
574
575 error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag),
576 UBC_READ | UBC_PARTIALOK | UBC_UNMAP_FLAG(vp));
577 }
578
579 out:
580 KASSERT(VOP_ISLOCKED(vp));
581
582 return error;
583 }
584
585 /* --------------------------------------------------------------------- */
586
587 int
588 tmpfs_write(void *v)
589 {
590 struct vnode *vp = ((struct vop_write_args *)v)->a_vp;
591 struct uio *uio = ((struct vop_write_args *)v)->a_uio;
592 int ioflag = ((struct vop_write_args *)v)->a_ioflag;
593
594 bool extended;
595 int error;
596 off_t oldsize;
597 struct proc *p = curproc;
598 struct tmpfs_node *node;
599 struct uvm_object *uobj;
600
601 KASSERT(VOP_ISLOCKED(vp));
602
603 node = VP_TO_TMPFS_NODE(vp);
604 oldsize = node->tn_size;
605
606 if (uio->uio_offset < 0 || vp->v_type != VREG) {
607 error = EINVAL;
608 goto out;
609 }
610
611 if (uio->uio_resid == 0) {
612 error = 0;
613 goto out;
614 }
615
616 if (((uio->uio_offset + uio->uio_resid) >
617 p->p_rlimit[RLIMIT_FSIZE].rlim_cur)) {
618 mutex_enter(proc_lock);
619 psignal(p, SIGXFSZ);
620 mutex_exit(proc_lock);
621 error = EFBIG;
622 goto out;
623 }
624
625 if (ioflag & IO_APPEND)
626 uio->uio_offset = node->tn_size;
627
628 extended = uio->uio_offset + uio->uio_resid > node->tn_size;
629 if (extended) {
630 error = tmpfs_reg_resize(vp, uio->uio_offset + uio->uio_resid);
631 if (error != 0)
632 goto out;
633 }
634
635 uobj = node->tn_spec.tn_reg.tn_aobj;
636 error = 0;
637 while (error == 0 && uio->uio_resid > 0) {
638 vsize_t len;
639
640 len = MIN(node->tn_size - uio->uio_offset, uio->uio_resid);
641 if (len == 0)
642 break;
643
644 error = ubc_uiomove(uobj, uio, len, IO_ADV_DECODE(ioflag),
645 UBC_WRITE | UBC_UNMAP_FLAG(vp));
646 }
647
648 node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_MODIFIED |
649 (extended ? TMPFS_NODE_CHANGED : 0);
650
651 if (error != 0)
652 (void)tmpfs_reg_resize(vp, oldsize);
653
654 VN_KNOTE(vp, NOTE_WRITE);
655
656 out:
657 KASSERT(VOP_ISLOCKED(vp));
658 KASSERT(IMPLIES(error == 0, uio->uio_resid == 0));
659 KASSERT(IMPLIES(error != 0, oldsize == node->tn_size));
660
661 return error;
662 }
663
664 /* --------------------------------------------------------------------- */
665
666 int
667 tmpfs_fsync(void *v)
668 {
669 struct vnode *vp = ((struct vop_fsync_args *)v)->a_vp;
670
671 KASSERT(VOP_ISLOCKED(vp));
672
673 tmpfs_update(vp, NULL, NULL, NULL, 0);
674
675 return 0;
676 }
677
678 /* --------------------------------------------------------------------- */
679
680 int
681 tmpfs_remove(void *v)
682 {
683 struct vnode *dvp = ((struct vop_remove_args *)v)->a_dvp;
684 struct vnode *vp = ((struct vop_remove_args *)v)->a_vp;
685 struct componentname *cnp = (((struct vop_remove_args *)v)->a_cnp);
686
687 int error;
688 struct tmpfs_dirent *de;
689 struct tmpfs_mount *tmp;
690 struct tmpfs_node *dnode;
691 struct tmpfs_node *node;
692
693 KASSERT(VOP_ISLOCKED(dvp));
694 KASSERT(VOP_ISLOCKED(vp));
695
696 if (vp->v_type == VDIR) {
697 error = EPERM;
698 goto out;
699 }
700
701 dnode = VP_TO_TMPFS_DIR(dvp);
702 node = VP_TO_TMPFS_NODE(vp);
703 tmp = VFS_TO_TMPFS(vp->v_mount);
704 de = tmpfs_dir_lookup(dnode, cnp);
705 KASSERT(de);
706 KASSERT(de->td_node == node);
707
708 /* Files marked as immutable or append-only cannot be deleted. */
709 if (node->tn_flags & (IMMUTABLE | APPEND)) {
710 error = EPERM;
711 goto out;
712 }
713
714 /* Remove the entry from the directory; as it is a file, we do not
715 * have to change the number of hard links of the directory. */
716 tmpfs_dir_detach(dvp, de);
717
718 /* Free the directory entry we just deleted. Note that the node
719 * referred by it will not be removed until the vnode is really
720 * reclaimed. */
721 tmpfs_free_dirent(tmp, de, true);
722
723 error = 0;
724
725 out:
726 vput(vp);
727 if (dvp == vp)
728 vrele(dvp);
729 else
730 vput(dvp);
731 PNBUF_PUT(cnp->cn_pnbuf);
732
733 return error;
734 }
735
736 /* --------------------------------------------------------------------- */
737
738 int
739 tmpfs_link(void *v)
740 {
741 struct vnode *dvp = ((struct vop_link_args *)v)->a_dvp;
742 struct vnode *vp = ((struct vop_link_args *)v)->a_vp;
743 struct componentname *cnp = ((struct vop_link_args *)v)->a_cnp;
744
745 int error;
746 struct tmpfs_dirent *de;
747 struct tmpfs_node *dnode;
748 struct tmpfs_node *node;
749
750 KASSERT(VOP_ISLOCKED(dvp));
751 KASSERT(cnp->cn_flags & HASBUF);
752 KASSERT(dvp != vp); /* XXX When can this be false? */
753
754 dnode = VP_TO_TMPFS_DIR(dvp);
755 node = VP_TO_TMPFS_NODE(vp);
756
757 /* Lock vp because we will need to run tmpfs_update over it, which
758 * needs the vnode to be locked. */
759 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
760
761 /* XXX: Why aren't the following two tests done by the caller? */
762
763 /* Hard links of directories are forbidden. */
764 if (vp->v_type == VDIR) {
765 error = EPERM;
766 goto out;
767 }
768
769 /* Cannot create cross-device links. */
770 if (dvp->v_mount != vp->v_mount) {
771 error = EXDEV;
772 goto out;
773 }
774
775 /* Ensure that we do not overflow the maximum number of links imposed
776 * by the system. */
777 KASSERT(node->tn_links <= LINK_MAX);
778 if (node->tn_links == LINK_MAX) {
779 error = EMLINK;
780 goto out;
781 }
782
783 /* We cannot create links of files marked immutable or append-only. */
784 if (node->tn_flags & (IMMUTABLE | APPEND)) {
785 error = EPERM;
786 goto out;
787 }
788
789 /* Allocate a new directory entry to represent the node. */
790 error = tmpfs_alloc_dirent(VFS_TO_TMPFS(vp->v_mount), node,
791 cnp->cn_nameptr, cnp->cn_namelen, &de);
792 if (error != 0)
793 goto out;
794
795 /* Insert the new directory entry into the appropriate directory. */
796 tmpfs_dir_attach(dvp, de);
797
798 /* vp link count has changed, so update node times. */
799 node->tn_status |= TMPFS_NODE_CHANGED;
800 tmpfs_update(vp, NULL, NULL, NULL, 0);
801
802 error = 0;
803
804 out:
805 VOP_UNLOCK(vp, 0);
806 PNBUF_PUT(cnp->cn_pnbuf);
807 vput(dvp);
808
809 return error;
810 }
811
812 /*
813 * tmpfs_rename: rename routine.
814 *
815 * Arguments: fdvp (from-parent vnode), fvp (from-leaf), tdvp (to-parent)
816 * and tvp (to-leaf), if exists (NULL if not).
817 *
818 * => Caller holds a reference on fdvp and fvp, they are unlocked.
819 * Note: fdvp and fvp can refer to the same object (i.e. when it is root).
820 *
821 * => Both tdvp and tvp are referenced and locked. It is our responsibility
822 * to release the references and unlock them (or destroy).
823 */
824 int
825 tmpfs_rename(void *v)
826 {
827 struct vnode *fdvp = ((struct vop_rename_args *)v)->a_fdvp;
828 struct vnode *fvp = ((struct vop_rename_args *)v)->a_fvp;
829 struct componentname *fcnp = ((struct vop_rename_args *)v)->a_fcnp;
830 struct vnode *tdvp = ((struct vop_rename_args *)v)->a_tdvp;
831 struct vnode *tvp = ((struct vop_rename_args *)v)->a_tvp;
832 struct componentname *tcnp = ((struct vop_rename_args *)v)->a_tcnp;
833
834 char *newname;
835 int error;
836 struct tmpfs_dirent *de, *de2;
837 struct tmpfs_mount *tmp;
838 struct tmpfs_node *fdnode;
839 struct tmpfs_node *fnode;
840 struct tmpfs_node *tnode;
841 struct tmpfs_node *tdnode;
842 size_t namelen;
843
844 KASSERT(VOP_ISLOCKED(tdvp));
845 KASSERT(IMPLIES(tvp != NULL, VOP_ISLOCKED(tvp) == LK_EXCLUSIVE));
846 KASSERT(fcnp->cn_flags & HASBUF);
847 KASSERT(tcnp->cn_flags & HASBUF);
848
849 newname = NULL;
850 namelen = 0;
851 tmp = NULL;
852
853 /* Disallow cross-device renames. */
854 if (fvp->v_mount != tdvp->v_mount ||
855 (tvp != NULL && fvp->v_mount != tvp->v_mount)) {
856 error = EXDEV;
857 goto out_unlocked;
858 }
859
860 fnode = VP_TO_TMPFS_NODE(fvp);
861 fdnode = VP_TO_TMPFS_DIR(fdvp);
862 tnode = (tvp == NULL) ? NULL : VP_TO_TMPFS_NODE(tvp);
863 tdnode = VP_TO_TMPFS_DIR(tdvp);
864 tmp = VFS_TO_TMPFS(tdvp->v_mount);
865
866 if (fdvp == tvp) {
867 error = 0;
868 goto out_unlocked;
869 }
870
871 /* If we need to move the directory between entries, lock the
872 * source so that we can safely operate on it. */
873
874 /* XXX: this is a potential locking order violation! */
875 if (fdnode != tdnode) {
876 vn_lock(fdvp, LK_EXCLUSIVE | LK_RETRY);
877 }
878
879 /*
880 * If the node we were renaming has scarpered, just give up.
881 */
882 de = tmpfs_dir_lookup(fdnode, fcnp);
883 if (de == NULL || de->td_node != fnode) {
884 error = ENOENT;
885 goto out;
886 }
887
888 /* If source and target is the same vnode, remove the source link. */
889 if (fvp == tvp) {
890 /*
891 * Detach and free the directory entry. Drops the link
892 * count on the node.
893 */
894 tmpfs_dir_detach(fdvp, de);
895 tmpfs_free_dirent(VFS_TO_TMPFS(fvp->v_mount), de, true);
896 VN_KNOTE(fdvp, NOTE_WRITE);
897 goto out_ok;
898 }
899
900 /* If replacing an existing entry, ensure we can do the operation. */
901 if (tvp != NULL) {
902 KASSERT(tnode != NULL);
903 if (fnode->tn_type == VDIR && tnode->tn_type == VDIR) {
904 if (tnode->tn_size > 0) {
905 error = ENOTEMPTY;
906 goto out;
907 }
908 } else if (fnode->tn_type == VDIR && tnode->tn_type != VDIR) {
909 error = ENOTDIR;
910 goto out;
911 } else if (fnode->tn_type != VDIR && tnode->tn_type == VDIR) {
912 error = EISDIR;
913 goto out;
914 } else {
915 KASSERT(fnode->tn_type != VDIR &&
916 tnode->tn_type != VDIR);
917 }
918 }
919
920 /* Ensure that we have enough memory to hold the new name, if it
921 * has to be changed. */
922 namelen = tcnp->cn_namelen;
923 if (fcnp->cn_namelen != tcnp->cn_namelen ||
924 memcmp(fcnp->cn_nameptr, tcnp->cn_nameptr, fcnp->cn_namelen) != 0) {
925 newname = tmpfs_str_pool_get(&tmp->tm_str_pool, namelen, 0);
926 if (newname == NULL) {
927 error = ENOSPC;
928 goto out;
929 }
930 }
931
932 /* If the node is being moved to another directory, we have to do
933 * the move. */
934 if (fdnode != tdnode) {
935 /* In case we are moving a directory, we have to adjust its
936 * parent to point to the new parent. */
937 if (de->td_node->tn_type == VDIR) {
938 struct tmpfs_node *n;
939
940 /* Ensure the target directory is not a child of the
941 * directory being moved. Otherwise, we'd end up
942 * with stale nodes. */
943 n = tdnode;
944 while (n != n->tn_spec.tn_dir.tn_parent) {
945 if (n == fnode) {
946 error = EINVAL;
947 goto out;
948 }
949 n = n->tn_spec.tn_dir.tn_parent;
950 }
951
952 /* Adjust the parent pointer. */
953 TMPFS_VALIDATE_DIR(fnode);
954 de->td_node->tn_spec.tn_dir.tn_parent = tdnode;
955
956 /* As a result of changing the target of the '..'
957 * entry, the link count of the source and target
958 * directories has to be adjusted. */
959 fdnode->tn_links--;
960 tdnode->tn_links++;
961 }
962
963 /* Do the move: just remove the entry from the source directory
964 * and insert it into the target one. */
965 tmpfs_dir_detach(fdvp, de);
966 tmpfs_dir_attach(tdvp, de);
967
968 /* Notify listeners of fdvp about the change in the directory.
969 * We can do it at this point because we aren't touching fdvp
970 * any more below. */
971 VN_KNOTE(fdvp, NOTE_WRITE);
972 }
973
974 /* If we are overwriting an entry, we have to remove the old one
975 * from the target directory. */
976 if (tvp != NULL) {
977 KASSERT(tnode != NULL);
978
979 /* Remove the old entry from the target directory.
980 * Note! This relies on tmpfs_dir_attach() putting the new
981 * node on the end of the target's node list. */
982 de2 = tmpfs_dir_lookup(tdnode, tcnp);
983 KASSERT(de2 != NULL);
984 KASSERT(de2->td_node == tnode);
985 tmpfs_dir_detach(tdvp, de2);
986
987 /* Free the directory entry we just deleted. Note that the
988 * node referred by it will not be removed until the vnode is
989 * really reclaimed. */
990 tmpfs_free_dirent(VFS_TO_TMPFS(tvp->v_mount), de2, true);
991 }
992
993 /* If the name has changed, we need to make it effective by changing
994 * it in the directory entry. */
995 if (newname != NULL) {
996 KASSERT(tcnp->cn_namelen < MAXNAMLEN);
997 KASSERT(tcnp->cn_namelen < 0xffff);
998
999 tmpfs_str_pool_put(&tmp->tm_str_pool, de->td_name,
1000 de->td_namelen);
1001 de->td_namelen = (uint16_t)namelen;
1002 memcpy(newname, tcnp->cn_nameptr, namelen);
1003 de->td_name = newname;
1004 newname = NULL;
1005
1006 fnode->tn_status |= TMPFS_NODE_CHANGED;
1007 tdnode->tn_status |= TMPFS_NODE_MODIFIED;
1008 }
1009 out_ok:
1010 /* Notify listeners of tdvp about the change in the directory (either
1011 * because a new entry was added or because one was removed) and
1012 * listeners of fvp about the rename. */
1013 VN_KNOTE(tdvp, NOTE_WRITE);
1014 VN_KNOTE(fvp, NOTE_RENAME);
1015
1016 error = 0;
1017
1018 out:
1019 if (fdnode != tdnode)
1020 VOP_UNLOCK(fdvp, 0);
1021
1022 out_unlocked:
1023 /* Release target nodes. */
1024 if (tdvp == tvp)
1025 vrele(tdvp);
1026 else
1027 vput(tdvp);
1028 if (tvp != NULL)
1029 vput(tvp);
1030
1031 /* Release source nodes. */
1032 vrele(fdvp);
1033 vrele(fvp);
1034
1035 if (newname != NULL)
1036 tmpfs_str_pool_put(&tmp->tm_str_pool, newname, namelen);
1037
1038 return error;
1039 }
1040
1041 /* --------------------------------------------------------------------- */
1042
1043 int
1044 tmpfs_mkdir(void *v)
1045 {
1046 struct vnode *dvp = ((struct vop_mkdir_args *)v)->a_dvp;
1047 struct vnode **vpp = ((struct vop_mkdir_args *)v)->a_vpp;
1048 struct componentname *cnp = ((struct vop_mkdir_args *)v)->a_cnp;
1049 struct vattr *vap = ((struct vop_mkdir_args *)v)->a_vap;
1050
1051 KASSERT(vap->va_type == VDIR);
1052
1053 return tmpfs_alloc_file(dvp, vpp, vap, cnp, NULL);
1054 }
1055
1056 /* --------------------------------------------------------------------- */
1057
1058 int
1059 tmpfs_rmdir(void *v)
1060 {
1061 struct vnode *dvp = ((struct vop_rmdir_args *)v)->a_dvp;
1062 struct vnode *vp = ((struct vop_rmdir_args *)v)->a_vp;
1063 struct componentname *cnp = ((struct vop_rmdir_args *)v)->a_cnp;
1064
1065 int error;
1066 struct tmpfs_dirent *de;
1067 struct tmpfs_mount *tmp;
1068 struct tmpfs_node *dnode;
1069 struct tmpfs_node *node;
1070
1071 KASSERT(VOP_ISLOCKED(dvp));
1072 KASSERT(VOP_ISLOCKED(vp));
1073
1074 tmp = VFS_TO_TMPFS(dvp->v_mount);
1075 dnode = VP_TO_TMPFS_DIR(dvp);
1076 node = VP_TO_TMPFS_DIR(vp);
1077 error = 0;
1078
1079 /* Directories with more than two entries ('.' and '..') cannot be
1080 * removed. */
1081 if (node->tn_size > 0) {
1082 error = ENOTEMPTY;
1083 goto out;
1084 }
1085
1086 /* This invariant holds only if we are not trying to remove "..".
1087 * We checked for that above so this is safe now. */
1088 KASSERT(node->tn_spec.tn_dir.tn_parent == dnode);
1089
1090 /* Get the directory entry associated with node (vp). */
1091 de = tmpfs_dir_lookup(dnode, cnp);
1092 KASSERT(de);
1093 KASSERT(de->td_node == node);
1094
1095 /* Check flags to see if we are allowed to remove the directory. */
1096 if (dnode->tn_flags & APPEND || node->tn_flags & (IMMUTABLE | APPEND)) {
1097 error = EPERM;
1098 goto out;
1099 }
1100
1101 /* Detach the directory entry from the directory (dnode). */
1102 tmpfs_dir_detach(dvp, de);
1103
1104 node->tn_links--;
1105 node->tn_status |= TMPFS_NODE_ACCESSED | TMPFS_NODE_CHANGED | \
1106 TMPFS_NODE_MODIFIED;
1107 node->tn_spec.tn_dir.tn_parent->tn_links--;
1108 node->tn_spec.tn_dir.tn_parent->tn_status |= TMPFS_NODE_ACCESSED | \
1109 TMPFS_NODE_CHANGED | TMPFS_NODE_MODIFIED;
1110
1111 /* Release the parent. */
1112 cache_purge(dvp); /* XXX Is this needed? */
1113
1114 /* Free the directory entry we just deleted. Note that the node
1115 * referred by it will not be removed until the vnode is really
1116 * reclaimed. */
1117 tmpfs_free_dirent(tmp, de, true);
1118
1119 KASSERT(node->tn_links == 0);
1120 out:
1121 /* Release the nodes. */
1122 vput(dvp);
1123 vput(vp);
1124 PNBUF_PUT(cnp->cn_pnbuf);
1125
1126 return error;
1127 }
1128
1129 /* --------------------------------------------------------------------- */
1130
1131 int
1132 tmpfs_symlink(void *v)
1133 {
1134 struct vnode *dvp = ((struct vop_symlink_args *)v)->a_dvp;
1135 struct vnode **vpp = ((struct vop_symlink_args *)v)->a_vpp;
1136 struct componentname *cnp = ((struct vop_symlink_args *)v)->a_cnp;
1137 struct vattr *vap = ((struct vop_symlink_args *)v)->a_vap;
1138 char *target = ((struct vop_symlink_args *)v)->a_target;
1139
1140 KASSERT(vap->va_type == VLNK);
1141
1142 return tmpfs_alloc_file(dvp, vpp, vap, cnp, target);
1143 }
1144
1145 /* --------------------------------------------------------------------- */
1146
1147 int
1148 tmpfs_readdir(void *v)
1149 {
1150 struct vnode *vp = ((struct vop_readdir_args *)v)->a_vp;
1151 struct uio *uio = ((struct vop_readdir_args *)v)->a_uio;
1152 int *eofflag = ((struct vop_readdir_args *)v)->a_eofflag;
1153 off_t **cookies = ((struct vop_readdir_args *)v)->a_cookies;
1154 int *ncookies = ((struct vop_readdir_args *)v)->a_ncookies;
1155
1156 int error;
1157 off_t startoff;
1158 off_t cnt;
1159 struct tmpfs_node *node;
1160
1161 KASSERT(VOP_ISLOCKED(vp));
1162
1163 /* This operation only makes sense on directory nodes. */
1164 if (vp->v_type != VDIR) {
1165 error = ENOTDIR;
1166 goto out;
1167 }
1168
1169 node = VP_TO_TMPFS_DIR(vp);
1170
1171 startoff = uio->uio_offset;
1172
1173 cnt = 0;
1174 if (uio->uio_offset == TMPFS_DIRCOOKIE_DOT) {
1175 error = tmpfs_dir_getdotdent(node, uio);
1176 if (error == -1) {
1177 error = 0;
1178 goto outok;
1179 } else if (error != 0)
1180 goto outok;
1181 cnt++;
1182 }
1183
1184 if (uio->uio_offset == TMPFS_DIRCOOKIE_DOTDOT) {
1185 error = tmpfs_dir_getdotdotdent(node, uio);
1186 if (error == -1) {
1187 error = 0;
1188 goto outok;
1189 } else if (error != 0)
1190 goto outok;
1191 cnt++;
1192 }
1193
1194 error = tmpfs_dir_getdents(node, uio, &cnt);
1195 if (error == -1)
1196 error = 0;
1197 KASSERT(error >= 0);
1198
1199 outok:
1200 /* This label assumes that startoff has been
1201 * initialized. If the compiler didn't spit out warnings, we'd
1202 * simply make this one be 'out' and drop 'outok'. */
1203
1204 if (eofflag != NULL)
1205 *eofflag =
1206 (error == 0 && uio->uio_offset == TMPFS_DIRCOOKIE_EOF);
1207
1208 /* Update NFS-related variables. */
1209 if (error == 0 && cookies != NULL && ncookies != NULL) {
1210 off_t i;
1211 off_t off = startoff;
1212 struct tmpfs_dirent *de = NULL;
1213
1214 *ncookies = cnt;
1215 *cookies = malloc(cnt * sizeof(off_t), M_TEMP, M_WAITOK);
1216
1217 for (i = 0; i < cnt; i++) {
1218 KASSERT(off != TMPFS_DIRCOOKIE_EOF);
1219 if (off == TMPFS_DIRCOOKIE_DOT) {
1220 off = TMPFS_DIRCOOKIE_DOTDOT;
1221 } else {
1222 if (off == TMPFS_DIRCOOKIE_DOTDOT) {
1223 de = TAILQ_FIRST(&node->tn_spec.
1224 tn_dir.tn_dir);
1225 } else if (de != NULL) {
1226 de = TAILQ_NEXT(de, td_entries);
1227 } else {
1228 de = tmpfs_dir_lookupbycookie(node,
1229 off);
1230 KASSERT(de != NULL);
1231 de = TAILQ_NEXT(de, td_entries);
1232 }
1233 if (de == NULL) {
1234 off = TMPFS_DIRCOOKIE_EOF;
1235 } else {
1236 off = tmpfs_dircookie(de);
1237 }
1238 }
1239
1240 (*cookies)[i] = off;
1241 }
1242 KASSERT(uio->uio_offset == off);
1243 }
1244
1245 out:
1246 KASSERT(VOP_ISLOCKED(vp));
1247
1248 return error;
1249 }
1250
1251 /* --------------------------------------------------------------------- */
1252
1253 int
1254 tmpfs_readlink(void *v)
1255 {
1256 struct vnode *vp = ((struct vop_readlink_args *)v)->a_vp;
1257 struct uio *uio = ((struct vop_readlink_args *)v)->a_uio;
1258
1259 int error;
1260 struct tmpfs_node *node;
1261
1262 KASSERT(VOP_ISLOCKED(vp));
1263 KASSERT(uio->uio_offset == 0);
1264 KASSERT(vp->v_type == VLNK);
1265
1266 node = VP_TO_TMPFS_NODE(vp);
1267
1268 error = uiomove(node->tn_spec.tn_lnk.tn_link,
1269 MIN(node->tn_size, uio->uio_resid), uio);
1270 node->tn_status |= TMPFS_NODE_ACCESSED;
1271
1272 KASSERT(VOP_ISLOCKED(vp));
1273
1274 return error;
1275 }
1276
1277 /* --------------------------------------------------------------------- */
1278
1279 int
1280 tmpfs_inactive(void *v)
1281 {
1282 struct vnode *vp = ((struct vop_inactive_args *)v)->a_vp;
1283
1284 struct tmpfs_node *node;
1285
1286 KASSERT(VOP_ISLOCKED(vp));
1287
1288 node = VP_TO_TMPFS_NODE(vp);
1289 *((struct vop_inactive_args *)v)->a_recycle = (node->tn_links == 0);
1290 VOP_UNLOCK(vp, 0);
1291
1292 return 0;
1293 }
1294
1295 /* --------------------------------------------------------------------- */
1296
1297 int
1298 tmpfs_reclaim(void *v)
1299 {
1300 struct vnode *vp = ((struct vop_reclaim_args *)v)->a_vp;
1301
1302 struct tmpfs_mount *tmp;
1303 struct tmpfs_node *node;
1304
1305 node = VP_TO_TMPFS_NODE(vp);
1306 tmp = VFS_TO_TMPFS(vp->v_mount);
1307
1308 cache_purge(vp);
1309 tmpfs_free_vp(vp);
1310
1311 /* If the node referenced by this vnode was deleted by the user,
1312 * we must free its associated data structures (now that the vnode
1313 * is being reclaimed). */
1314 if (node->tn_links == 0)
1315 tmpfs_free_node(tmp, node);
1316
1317 KASSERT(vp->v_data == NULL);
1318
1319 return 0;
1320 }
1321
1322 /* --------------------------------------------------------------------- */
1323
1324 int
1325 tmpfs_print(void *v)
1326 {
1327 struct vnode *vp = ((struct vop_print_args *)v)->a_vp;
1328
1329 struct tmpfs_node *node;
1330
1331 node = VP_TO_TMPFS_NODE(vp);
1332
1333 printf("tag VT_TMPFS, tmpfs_node %p, flags 0x%x, links %d\n",
1334 node, node->tn_flags, node->tn_links);
1335 printf("\tmode 0%o, owner %d, group %d, size %" PRIdMAX
1336 ", status 0x%x\n",
1337 node->tn_mode, node->tn_uid, node->tn_gid,
1338 (uintmax_t)node->tn_size, node->tn_status);
1339 if (vp->v_type == VFIFO)
1340 fifo_printinfo(vp);
1341 printf("\n");
1342
1343 return 0;
1344 }
1345
1346 /* --------------------------------------------------------------------- */
1347
1348 int
1349 tmpfs_pathconf(void *v)
1350 {
1351 int name = ((struct vop_pathconf_args *)v)->a_name;
1352 register_t *retval = ((struct vop_pathconf_args *)v)->a_retval;
1353
1354 int error;
1355
1356 error = 0;
1357
1358 switch (name) {
1359 case _PC_LINK_MAX:
1360 *retval = LINK_MAX;
1361 break;
1362
1363 case _PC_NAME_MAX:
1364 *retval = NAME_MAX;
1365 break;
1366
1367 case _PC_PATH_MAX:
1368 *retval = PATH_MAX;
1369 break;
1370
1371 case _PC_PIPE_BUF:
1372 *retval = PIPE_BUF;
1373 break;
1374
1375 case _PC_CHOWN_RESTRICTED:
1376 *retval = 1;
1377 break;
1378
1379 case _PC_NO_TRUNC:
1380 *retval = 1;
1381 break;
1382
1383 case _PC_SYNC_IO:
1384 *retval = 1;
1385 break;
1386
1387 case _PC_FILESIZEBITS:
1388 *retval = 0; /* XXX Don't know which value should I return. */
1389 break;
1390
1391 default:
1392 error = EINVAL;
1393 }
1394
1395 return error;
1396 }
1397
1398 /* --------------------------------------------------------------------- */
1399
1400 int
1401 tmpfs_advlock(void *v)
1402 {
1403 struct vnode *vp = ((struct vop_advlock_args *)v)->a_vp;
1404
1405 struct tmpfs_node *node;
1406
1407 node = VP_TO_TMPFS_NODE(vp);
1408
1409 return lf_advlock(v, &node->tn_lockf, node->tn_size);
1410 }
1411
1412 /* --------------------------------------------------------------------- */
1413
1414 int
1415 tmpfs_getpages(void *v)
1416 {
1417 struct vnode *vp = ((struct vop_getpages_args *)v)->a_vp;
1418 voff_t offset = ((struct vop_getpages_args *)v)->a_offset;
1419 struct vm_page **m = ((struct vop_getpages_args *)v)->a_m;
1420 int *count = ((struct vop_getpages_args *)v)->a_count;
1421 int centeridx = ((struct vop_getpages_args *)v)->a_centeridx;
1422 vm_prot_t access_type = ((struct vop_getpages_args *)v)->a_access_type;
1423 int advice = ((struct vop_getpages_args *)v)->a_advice;
1424 int flags = ((struct vop_getpages_args *)v)->a_flags;
1425
1426 int error;
1427 int i;
1428 struct tmpfs_node *node;
1429 struct uvm_object *uobj;
1430 int npages = *count;
1431
1432 KASSERT(vp->v_type == VREG);
1433 KASSERT(mutex_owned(&vp->v_interlock));
1434
1435 node = VP_TO_TMPFS_NODE(vp);
1436 uobj = node->tn_spec.tn_reg.tn_aobj;
1437
1438 /* We currently don't rely on PGO_PASTEOF. */
1439
1440 if (vp->v_size <= offset + (centeridx << PAGE_SHIFT)) {
1441 if ((flags & PGO_LOCKED) == 0)
1442 mutex_exit(&vp->v_interlock);
1443 return EINVAL;
1444 }
1445
1446 if (vp->v_size < offset + (npages << PAGE_SHIFT)) {
1447 npages = (round_page(vp->v_size) - offset) >> PAGE_SHIFT;
1448 }
1449
1450 if ((flags & PGO_LOCKED) != 0)
1451 return EBUSY;
1452
1453 if ((flags & PGO_NOTIMESTAMP) == 0) {
1454 if ((vp->v_mount->mnt_flag & MNT_NOATIME) == 0)
1455 node->tn_status |= TMPFS_NODE_ACCESSED;
1456
1457 if ((access_type & VM_PROT_WRITE) != 0)
1458 node->tn_status |= TMPFS_NODE_MODIFIED;
1459 }
1460
1461 mutex_exit(&vp->v_interlock);
1462
1463 /*
1464 * Make sure that the array on which we will store the
1465 * gotten pages is clean. Otherwise uao_get (pointed to by
1466 * the pgo_get below) gets confused and does not return the
1467 * appropriate pages.
1468 *
1469 * XXX This shall be revisited when kern/32166 is addressed
1470 * because the loop to clean m[i] will most likely be redundant
1471 * as well as the PGO_ALLPAGES flag.
1472 */
1473 if (m != NULL)
1474 for (i = 0; i < npages; i++)
1475 m[i] = NULL;
1476 mutex_enter(&uobj->vmobjlock);
1477 error = (*uobj->pgops->pgo_get)(uobj, offset, m, &npages, centeridx,
1478 access_type, advice, flags | PGO_ALLPAGES);
1479 #if defined(DEBUG)
1480 {
1481 /* Make sure that all the pages we return are valid. */
1482 int dbgi;
1483 if (error == 0 && m != NULL)
1484 for (dbgi = 0; dbgi < npages; dbgi++)
1485 KASSERT(m[dbgi] != NULL);
1486 }
1487 #endif
1488
1489 return error;
1490 }
1491
1492 /* --------------------------------------------------------------------- */
1493
1494 int
1495 tmpfs_putpages(void *v)
1496 {
1497 struct vnode *vp = ((struct vop_putpages_args *)v)->a_vp;
1498 voff_t offlo = ((struct vop_putpages_args *)v)->a_offlo;
1499 voff_t offhi = ((struct vop_putpages_args *)v)->a_offhi;
1500 int flags = ((struct vop_putpages_args *)v)->a_flags;
1501
1502 int error;
1503 struct tmpfs_node *node;
1504 struct uvm_object *uobj;
1505
1506 KASSERT(mutex_owned(&vp->v_interlock));
1507
1508 node = VP_TO_TMPFS_NODE(vp);
1509
1510 if (vp->v_type != VREG) {
1511 mutex_exit(&vp->v_interlock);
1512 return 0;
1513 }
1514
1515 uobj = node->tn_spec.tn_reg.tn_aobj;
1516 mutex_exit(&vp->v_interlock);
1517
1518 mutex_enter(&uobj->vmobjlock);
1519 error = (*uobj->pgops->pgo_put)(uobj, offlo, offhi, flags);
1520
1521 /* XXX mtime */
1522
1523 return error;
1524 }
1525