1 /*-
2 * SPDX-License-Identifier: BSD-3-Clause
3 *
4 * Copyright (c) 1989, 1993
5 * The Regents of the University of California. All rights reserved.
6 *
7 * This code is derived from software contributed
8 * to Berkeley by John Heidemann of the UCLA Ficus project.
9 *
10 * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project
11 *
12 * Redistribution and use in source and binary forms, with or without
13 * modification, are permitted provided that the following conditions
14 * are met:
15 * 1. Redistributions of source code must retain the above copyright
16 * notice, this list of conditions and the following disclaimer.
17 * 2. Redistributions in binary form must reproduce the above copyright
18 * notice, this list of conditions and the following disclaimer in the
19 * documentation and/or other materials provided with the distribution.
20 * 3. Neither the name of the University nor the names of its contributors
21 * may be used to endorse or promote products derived from this software
22 * without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * SUCH DAMAGE.
35 */
36
37 #include <sys/cdefs.h>
38 __FBSDID("$FreeBSD$");
39
40 #include <sys/param.h>
41 #include <sys/systm.h>
42 #include <sys/bio.h>
43 #include <sys/buf.h>
44 #include <sys/conf.h>
45 #include <sys/event.h>
46 #include <sys/filio.h>
47 #include <sys/kernel.h>
48 #include <sys/limits.h>
49 #include <sys/lock.h>
50 #include <sys/lockf.h>
51 #include <sys/malloc.h>
52 #include <sys/mount.h>
53 #include <sys/namei.h>
54 #include <sys/rwlock.h>
55 #include <sys/fcntl.h>
56 #include <sys/unistd.h>
57 #include <sys/vnode.h>
58 #include <sys/dirent.h>
59 #include <sys/poll.h>
60 #include <sys/stat.h>
61 #include <security/audit/audit.h>
62 #include <sys/priv.h>
63
64 #include <security/mac/mac_framework.h>
65
66 #include <vm/vm.h>
67 #include <vm/vm_object.h>
68 #include <vm/vm_extern.h>
69 #include <vm/pmap.h>
70 #include <vm/vm_map.h>
71 #include <vm/vm_page.h>
72 #include <vm/vm_pager.h>
73 #include <vm/vnode_pager.h>
74
75 static int vop_nolookup(struct vop_lookup_args *);
76 static int vop_norename(struct vop_rename_args *);
77 static int vop_nostrategy(struct vop_strategy_args *);
78 static int get_next_dirent(struct vnode *vp, struct dirent **dpp,
79 char *dirbuf, int dirbuflen, off_t *off,
80 char **cpos, int *len, int *eofflag,
81 struct thread *td);
82 static int dirent_exists(struct vnode *vp, const char *dirname,
83 struct thread *td);
84
85 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4)
86
87 static int vop_stdis_text(struct vop_is_text_args *ap);
88 static int vop_stdunset_text(struct vop_unset_text_args *ap);
89 static int vop_stdadd_writecount(struct vop_add_writecount_args *ap);
90 static int vop_stdcopy_file_range(struct vop_copy_file_range_args *ap);
91 static int vop_stdfdatasync(struct vop_fdatasync_args *ap);
92 static int vop_stdgetpages_async(struct vop_getpages_async_args *ap);
93 static int vop_stdread_pgcache(struct vop_read_pgcache_args *ap);
94 static int vop_stdstat(struct vop_stat_args *ap);
95 static int vop_stdvput_pair(struct vop_vput_pair_args *ap);
96
97 /*
98 * This vnode table stores what we want to do if the filesystem doesn't
99 * implement a particular VOP.
100 *
101 * If there is no specific entry here, we will return EOPNOTSUPP.
102 *
103 * Note that every filesystem has to implement either vop_access
104 * or vop_accessx; failing to do so will result in immediate crash
105 * due to stack overflow, as vop_stdaccess() calls vop_stdaccessx(),
106 * which calls vop_stdaccess() etc.
107 */
108
109 struct vop_vector default_vnodeops = {
110 .vop_default = NULL,
111 .vop_bypass = VOP_EOPNOTSUPP,
112
113 .vop_access = vop_stdaccess,
114 .vop_accessx = vop_stdaccessx,
115 .vop_advise = vop_stdadvise,
116 .vop_advlock = vop_stdadvlock,
117 .vop_advlockasync = vop_stdadvlockasync,
118 .vop_advlockpurge = vop_stdadvlockpurge,
119 .vop_allocate = vop_stdallocate,
120 .vop_bmap = vop_stdbmap,
121 .vop_close = VOP_NULL,
122 .vop_fsync = VOP_NULL,
123 .vop_stat = vop_stdstat,
124 .vop_fdatasync = vop_stdfdatasync,
125 .vop_getpages = vop_stdgetpages,
126 .vop_getpages_async = vop_stdgetpages_async,
127 .vop_getwritemount = vop_stdgetwritemount,
128 .vop_inactive = VOP_NULL,
129 .vop_need_inactive = vop_stdneed_inactive,
130 .vop_ioctl = vop_stdioctl,
131 .vop_kqfilter = vop_stdkqfilter,
132 .vop_islocked = vop_stdislocked,
133 .vop_lock1 = vop_stdlock,
134 .vop_lookup = vop_nolookup,
135 .vop_open = VOP_NULL,
136 .vop_pathconf = VOP_EINVAL,
137 .vop_poll = vop_nopoll,
138 .vop_putpages = vop_stdputpages,
139 .vop_readlink = VOP_EINVAL,
140 .vop_read_pgcache = vop_stdread_pgcache,
141 .vop_rename = vop_norename,
142 .vop_revoke = VOP_PANIC,
143 .vop_strategy = vop_nostrategy,
144 .vop_unlock = vop_stdunlock,
145 .vop_vptocnp = vop_stdvptocnp,
146 .vop_vptofh = vop_stdvptofh,
147 .vop_unp_bind = vop_stdunp_bind,
148 .vop_unp_connect = vop_stdunp_connect,
149 .vop_unp_detach = vop_stdunp_detach,
150 .vop_is_text = vop_stdis_text,
151 .vop_set_text = vop_stdset_text,
152 .vop_unset_text = vop_stdunset_text,
153 .vop_add_writecount = vop_stdadd_writecount,
154 .vop_copy_file_range = vop_stdcopy_file_range,
155 .vop_vput_pair = vop_stdvput_pair,
156 };
157 VFS_VOP_VECTOR_REGISTER(default_vnodeops);
158
159 /*
160 * Series of placeholder functions for various error returns for
161 * VOPs.
162 */
163
164 int
165 vop_eopnotsupp(struct vop_generic_args *ap)
166 {
167 /*
168 printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name);
169 */
170
171 return (EOPNOTSUPP);
172 }
173
174 int
175 vop_ebadf(struct vop_generic_args *ap)
176 {
177
178 return (EBADF);
179 }
180
181 int
182 vop_enotty(struct vop_generic_args *ap)
183 {
184
185 return (ENOTTY);
186 }
187
188 int
189 vop_einval(struct vop_generic_args *ap)
190 {
191
192 return (EINVAL);
193 }
194
195 int
196 vop_enoent(struct vop_generic_args *ap)
197 {
198
199 return (ENOENT);
200 }
201
202 int
203 vop_eagain(struct vop_generic_args *ap)
204 {
205
206 return (EAGAIN);
207 }
208
209 int
210 vop_null(struct vop_generic_args *ap)
211 {
212
213 return (0);
214 }
215
216 /*
217 * Helper function to panic on some bad VOPs in some filesystems.
218 */
219 int
220 vop_panic(struct vop_generic_args *ap)
221 {
222
223 panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name);
224 }
225
226 /*
227 * vop_std<something> and vop_no<something> are default functions for use by
228 * filesystems that need the "default reasonable" implementation for a
229 * particular operation.
230 *
231 * The documentation for the operations they implement exists (if it exists)
232 * in the VOP_<SOMETHING>(9) manpage (all uppercase).
233 */
234
235 /*
236 * Default vop for filesystems that do not support name lookup
237 */
238 static int
239 vop_nolookup(ap)
240 struct vop_lookup_args /* {
241 struct vnode *a_dvp;
242 struct vnode **a_vpp;
243 struct componentname *a_cnp;
244 } */ *ap;
245 {
246
247 *ap->a_vpp = NULL;
248 return (ENOTDIR);
249 }
250
251 /*
252 * vop_norename:
253 *
254 * Handle unlock and reference counting for arguments of vop_rename
255 * for filesystems that do not implement rename operation.
256 */
257 static int
258 vop_norename(struct vop_rename_args *ap)
259 {
260
261 vop_rename_fail(ap);
262 return (EOPNOTSUPP);
263 }
264
265 /*
266 * vop_nostrategy:
267 *
268 * Strategy routine for VFS devices that have none.
269 *
270 * BIO_ERROR and B_INVAL must be cleared prior to calling any strategy
271 * routine. Typically this is done for a BIO_READ strategy call.
272 * Typically B_INVAL is assumed to already be clear prior to a write
273 * and should not be cleared manually unless you just made the buffer
274 * invalid. BIO_ERROR should be cleared either way.
275 */
276
277 static int
278 vop_nostrategy (struct vop_strategy_args *ap)
279 {
280 printf("No strategy for buffer at %p\n", ap->a_bp);
281 vn_printf(ap->a_vp, "vnode ");
282 ap->a_bp->b_ioflags |= BIO_ERROR;
283 ap->a_bp->b_error = EOPNOTSUPP;
284 bufdone(ap->a_bp);
285 return (EOPNOTSUPP);
286 }
287
288 static int
289 get_next_dirent(struct vnode *vp, struct dirent **dpp, char *dirbuf,
290 int dirbuflen, off_t *off, char **cpos, int *len,
291 int *eofflag, struct thread *td)
292 {
293 int error, reclen;
294 struct uio uio;
295 struct iovec iov;
296 struct dirent *dp;
297
298 KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
299 KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
300
301 if (*len == 0) {
302 iov.iov_base = dirbuf;
303 iov.iov_len = dirbuflen;
304
305 uio.uio_iov = &iov;
306 uio.uio_iovcnt = 1;
307 uio.uio_offset = *off;
308 uio.uio_resid = dirbuflen;
309 uio.uio_segflg = UIO_SYSSPACE;
310 uio.uio_rw = UIO_READ;
311 uio.uio_td = td;
312
313 *eofflag = 0;
314
315 #ifdef MAC
316 error = mac_vnode_check_readdir(td->td_ucred, vp);
317 if (error == 0)
318 #endif
319 error = VOP_READDIR(vp, &uio, td->td_ucred, eofflag,
320 NULL, NULL);
321 if (error)
322 return (error);
323
324 *off = uio.uio_offset;
325
326 *cpos = dirbuf;
327 *len = (dirbuflen - uio.uio_resid);
328
329 if (*len == 0)
330 return (ENOENT);
331 }
332
333 dp = (struct dirent *)(*cpos);
334 reclen = dp->d_reclen;
335 *dpp = dp;
336
337 /* check for malformed directory.. */
338 if (reclen < DIRENT_MINSIZE)
339 return (EINVAL);
340
341 *cpos += reclen;
342 *len -= reclen;
343
344 return (0);
345 }
346
347 /*
348 * Check if a named file exists in a given directory vnode.
349 */
350 static int
351 dirent_exists(struct vnode *vp, const char *dirname, struct thread *td)
352 {
353 char *dirbuf, *cpos;
354 int error, eofflag, dirbuflen, len, found;
355 off_t off;
356 struct dirent *dp;
357 struct vattr va;
358
359 KASSERT(VOP_ISLOCKED(vp), ("vp %p is not locked", vp));
360 KASSERT(vp->v_type == VDIR, ("vp %p is not a directory", vp));
361
362 found = 0;
363
364 error = VOP_GETATTR(vp, &va, td->td_ucred);
365 if (error)
366 return (found);
367
368 dirbuflen = DEV_BSIZE;
369 if (dirbuflen < va.va_blocksize)
370 dirbuflen = va.va_blocksize;
371 dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
372
373 off = 0;
374 len = 0;
375 do {
376 error = get_next_dirent(vp, &dp, dirbuf, dirbuflen, &off,
377 &cpos, &len, &eofflag, td);
378 if (error)
379 goto out;
380
381 if (dp->d_type != DT_WHT && dp->d_fileno != 0 &&
382 strcmp(dp->d_name, dirname) == 0) {
383 found = 1;
384 goto out;
385 }
386 } while (len > 0 || !eofflag);
387
388 out:
389 free(dirbuf, M_TEMP);
390 return (found);
391 }
392
393 int
394 vop_stdaccess(struct vop_access_args *ap)
395 {
396
397 KASSERT((ap->a_accmode & ~(VEXEC | VWRITE | VREAD | VADMIN |
398 VAPPEND)) == 0, ("invalid bit in accmode"));
399
400 return (VOP_ACCESSX(ap->a_vp, ap->a_accmode, ap->a_cred, ap->a_td));
401 }
402
403 int
404 vop_stdaccessx(struct vop_accessx_args *ap)
405 {
406 int error;
407 accmode_t accmode = ap->a_accmode;
408
409 error = vfs_unixify_accmode(&accmode);
410 if (error != 0)
411 return (error);
412
413 if (accmode == 0)
414 return (0);
415
416 return (VOP_ACCESS(ap->a_vp, accmode, ap->a_cred, ap->a_td));
417 }
418
419 /*
420 * Advisory record locking support
421 */
422 int
423 vop_stdadvlock(struct vop_advlock_args *ap)
424 {
425 struct vnode *vp;
426 struct mount *mp;
427 struct vattr vattr;
428 int error;
429
430 vp = ap->a_vp;
431
432 /*
433 * Provide atomicity of open(O_CREAT | O_EXCL | O_EXLOCK) for
434 * local filesystems. See vn_open_cred() for reciprocal part.
435 */
436 mp = vp->v_mount;
437 if (mp != NULL && (mp->mnt_flag & MNT_LOCAL) != 0 &&
438 ap->a_op == F_SETLK && (ap->a_flags & F_FIRSTOPEN) == 0) {
439 VI_LOCK(vp);
440 while ((vp->v_iflag & VI_FOPENING) != 0)
441 msleep(vp, VI_MTX(vp), PLOCK, "lockfo", 0);
442 VI_UNLOCK(vp);
443 }
444
445 if (ap->a_fl->l_whence == SEEK_END) {
446 /*
447 * The NFSv4 server must avoid doing a vn_lock() here, since it
448 * can deadlock the nfsd threads, due to a LOR. Fortunately
449 * the NFSv4 server always uses SEEK_SET and this code is
450 * only required for the SEEK_END case.
451 */
452 vn_lock(vp, LK_SHARED | LK_RETRY);
453 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
454 VOP_UNLOCK(vp);
455 if (error)
456 return (error);
457 } else
458 vattr.va_size = 0;
459
460 return (lf_advlock(ap, &(vp->v_lockf), vattr.va_size));
461 }
462
463 int
464 vop_stdadvlockasync(struct vop_advlockasync_args *ap)
465 {
466 struct vnode *vp;
467 struct vattr vattr;
468 int error;
469
470 vp = ap->a_vp;
471 if (ap->a_fl->l_whence == SEEK_END) {
472 /* The size argument is only needed for SEEK_END. */
473 vn_lock(vp, LK_SHARED | LK_RETRY);
474 error = VOP_GETATTR(vp, &vattr, curthread->td_ucred);
475 VOP_UNLOCK(vp);
476 if (error)
477 return (error);
478 } else
479 vattr.va_size = 0;
480
481 return (lf_advlockasync(ap, &(vp->v_lockf), vattr.va_size));
482 }
483
484 int
485 vop_stdadvlockpurge(struct vop_advlockpurge_args *ap)
486 {
487 struct vnode *vp;
488
489 vp = ap->a_vp;
490 lf_purgelocks(vp, &vp->v_lockf);
491 return (0);
492 }
493
494 /*
495 * vop_stdpathconf:
496 *
497 * Standard implementation of POSIX pathconf, to get information about limits
498 * for a filesystem.
499 * Override per filesystem for the case where the filesystem has smaller
500 * limits.
501 */
502 int
503 vop_stdpathconf(ap)
504 struct vop_pathconf_args /* {
505 struct vnode *a_vp;
506 int a_name;
507 int *a_retval;
508 } */ *ap;
509 {
510
511 switch (ap->a_name) {
512 case _PC_ASYNC_IO:
513 *ap->a_retval = _POSIX_ASYNCHRONOUS_IO;
514 return (0);
515 case _PC_PATH_MAX:
516 *ap->a_retval = PATH_MAX;
517 return (0);
518 case _PC_ACL_EXTENDED:
519 case _PC_ACL_NFS4:
520 case _PC_CAP_PRESENT:
521 case _PC_INF_PRESENT:
522 case _PC_MAC_PRESENT:
523 *ap->a_retval = 0;
524 return (0);
525 default:
526 return (EINVAL);
527 }
528 /* NOTREACHED */
529 }
530
531 /*
532 * Standard lock, unlock and islocked functions.
533 */
534 int
535 vop_stdlock(ap)
536 struct vop_lock1_args /* {
537 struct vnode *a_vp;
538 int a_flags;
539 char *file;
540 int line;
541 } */ *ap;
542 {
543 struct vnode *vp = ap->a_vp;
544 struct mtx *ilk;
545
546 ilk = VI_MTX(vp);
547 return (lockmgr_lock_flags(vp->v_vnlock, ap->a_flags,
548 &ilk->lock_object, ap->a_file, ap->a_line));
549 }
550
551 /* See above. */
552 int
553 vop_stdunlock(ap)
554 struct vop_unlock_args /* {
555 struct vnode *a_vp;
556 } */ *ap;
557 {
558 struct vnode *vp = ap->a_vp;
559
560 return (lockmgr_unlock(vp->v_vnlock));
561 }
562
563 /* See above. */
564 int
565 vop_stdislocked(ap)
566 struct vop_islocked_args /* {
567 struct vnode *a_vp;
568 } */ *ap;
569 {
570
571 return (lockstatus(ap->a_vp->v_vnlock));
572 }
573
574 /*
575 * Variants of the above set.
576 *
577 * Differences are:
578 * - shared locking disablement is not supported
579 * - v_vnlock pointer is not honored
580 */
581 int
582 vop_lock(ap)
583 struct vop_lock1_args /* {
584 struct vnode *a_vp;
585 int a_flags;
586 char *file;
587 int line;
588 } */ *ap;
589 {
590 struct vnode *vp = ap->a_vp;
591 int flags = ap->a_flags;
592 struct mtx *ilk;
593
594 MPASS(vp->v_vnlock == &vp->v_lock);
595
596 if (__predict_false((flags & ~(LK_TYPE_MASK | LK_NODDLKTREAT | LK_RETRY)) != 0))
597 goto other;
598
599 switch (flags & LK_TYPE_MASK) {
600 case LK_SHARED:
601 return (lockmgr_slock(&vp->v_lock, flags, ap->a_file, ap->a_line));
602 case LK_EXCLUSIVE:
603 return (lockmgr_xlock(&vp->v_lock, flags, ap->a_file, ap->a_line));
604 }
605 other:
606 ilk = VI_MTX(vp);
607 return (lockmgr_lock_flags(&vp->v_lock, flags,
608 &ilk->lock_object, ap->a_file, ap->a_line));
609 }
610
611 int
612 vop_unlock(ap)
613 struct vop_unlock_args /* {
614 struct vnode *a_vp;
615 } */ *ap;
616 {
617 struct vnode *vp = ap->a_vp;
618
619 MPASS(vp->v_vnlock == &vp->v_lock);
620
621 return (lockmgr_unlock(&vp->v_lock));
622 }
623
624 int
625 vop_islocked(ap)
626 struct vop_islocked_args /* {
627 struct vnode *a_vp;
628 } */ *ap;
629 {
630 struct vnode *vp = ap->a_vp;
631
632 MPASS(vp->v_vnlock == &vp->v_lock);
633
634 return (lockstatus(&vp->v_lock));
635 }
636
637 /*
638 * Return true for select/poll.
639 */
640 int
641 vop_nopoll(ap)
642 struct vop_poll_args /* {
643 struct vnode *a_vp;
644 int a_events;
645 struct ucred *a_cred;
646 struct thread *a_td;
647 } */ *ap;
648 {
649
650 if (ap->a_events & ~POLLSTANDARD)
651 return (POLLNVAL);
652 return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
653 }
654
655 /*
656 * Implement poll for local filesystems that support it.
657 */
658 int
659 vop_stdpoll(ap)
660 struct vop_poll_args /* {
661 struct vnode *a_vp;
662 int a_events;
663 struct ucred *a_cred;
664 struct thread *a_td;
665 } */ *ap;
666 {
667 if (ap->a_events & ~POLLSTANDARD)
668 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events));
669 return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM));
670 }
671
672 /*
673 * Return our mount point, as we will take charge of the writes.
674 */
675 int
676 vop_stdgetwritemount(ap)
677 struct vop_getwritemount_args /* {
678 struct vnode *a_vp;
679 struct mount **a_mpp;
680 } */ *ap;
681 {
682 struct mount *mp;
683 struct vnode *vp;
684
685 /*
686 * Note that having a reference does not prevent forced unmount from
687 * setting ->v_mount to NULL after the lock gets released. This is of
688 * no consequence for typical consumers (most notably vn_start_write)
689 * since in this case the vnode is VIRF_DOOMED. Unmount might have
690 * progressed far enough that its completion is only delayed by the
691 * reference obtained here. The consumer only needs to concern itself
692 * with releasing it.
693 */
694 vp = ap->a_vp;
695 mp = vfs_ref_from_vp(vp);
696 *(ap->a_mpp) = mp;
697 return (0);
698 }
699
700 /*
701 * If the file system doesn't implement VOP_BMAP, then return sensible defaults:
702 * - Return the vnode's bufobj instead of any underlying device's bufobj
703 * - Calculate the physical block number as if there were equal size
704 * consecutive blocks, but
705 * - Report no contiguous runs of blocks.
706 */
707 int
708 vop_stdbmap(ap)
709 struct vop_bmap_args /* {
710 struct vnode *a_vp;
711 daddr_t a_bn;
712 struct bufobj **a_bop;
713 daddr_t *a_bnp;
714 int *a_runp;
715 int *a_runb;
716 } */ *ap;
717 {
718
719 if (ap->a_bop != NULL)
720 *ap->a_bop = &ap->a_vp->v_bufobj;
721 if (ap->a_bnp != NULL)
722 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize);
723 if (ap->a_runp != NULL)
724 *ap->a_runp = 0;
725 if (ap->a_runb != NULL)
726 *ap->a_runb = 0;
727 return (0);
728 }
729
730 int
731 vop_stdfsync(ap)
732 struct vop_fsync_args /* {
733 struct vnode *a_vp;
734 int a_waitfor;
735 struct thread *a_td;
736 } */ *ap;
737 {
738
739 return (vn_fsync_buf(ap->a_vp, ap->a_waitfor));
740 }
741
742 static int
743 vop_stdfdatasync(struct vop_fdatasync_args *ap)
744 {
745
746 return (VOP_FSYNC(ap->a_vp, MNT_WAIT, ap->a_td));
747 }
748
749 int
750 vop_stdfdatasync_buf(struct vop_fdatasync_args *ap)
751 {
752
753 return (vn_fsync_buf(ap->a_vp, MNT_WAIT));
754 }
755
756 /* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */
757 int
758 vop_stdgetpages(ap)
759 struct vop_getpages_args /* {
760 struct vnode *a_vp;
761 vm_page_t *a_m;
762 int a_count;
763 int *a_rbehind;
764 int *a_rahead;
765 } */ *ap;
766 {
767
768 return vnode_pager_generic_getpages(ap->a_vp, ap->a_m,
769 ap->a_count, ap->a_rbehind, ap->a_rahead, NULL, NULL);
770 }
771
772 static int
773 vop_stdgetpages_async(struct vop_getpages_async_args *ap)
774 {
775 int error;
776
777 error = VOP_GETPAGES(ap->a_vp, ap->a_m, ap->a_count, ap->a_rbehind,
778 ap->a_rahead);
779 if (ap->a_iodone != NULL)
780 ap->a_iodone(ap->a_arg, ap->a_m, ap->a_count, error);
781 return (error);
782 }
783
784 int
785 vop_stdkqfilter(struct vop_kqfilter_args *ap)
786 {
787 return vfs_kqfilter(ap);
788 }
789
790 /* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */
791 int
792 vop_stdputpages(ap)
793 struct vop_putpages_args /* {
794 struct vnode *a_vp;
795 vm_page_t *a_m;
796 int a_count;
797 int a_sync;
798 int *a_rtvals;
799 } */ *ap;
800 {
801
802 return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
803 ap->a_sync, ap->a_rtvals);
804 }
805
806 int
807 vop_stdvptofh(struct vop_vptofh_args *ap)
808 {
809 return (EOPNOTSUPP);
810 }
811
812 int
813 vop_stdvptocnp(struct vop_vptocnp_args *ap)
814 {
815 struct vnode *vp = ap->a_vp;
816 struct vnode **dvp = ap->a_vpp;
817 struct ucred *cred;
818 char *buf = ap->a_buf;
819 size_t *buflen = ap->a_buflen;
820 char *dirbuf, *cpos;
821 int i, error, eofflag, dirbuflen, flags, locked, len, covered;
822 off_t off;
823 ino_t fileno;
824 struct vattr va;
825 struct nameidata nd;
826 struct thread *td;
827 struct dirent *dp;
828 struct vnode *mvp;
829
830 i = *buflen;
831 error = 0;
832 covered = 0;
833 td = curthread;
834 cred = td->td_ucred;
835
836 if (vp->v_type != VDIR)
837 return (ENOENT);
838
839 error = VOP_GETATTR(vp, &va, cred);
840 if (error)
841 return (error);
842
843 VREF(vp);
844 locked = VOP_ISLOCKED(vp);
845 VOP_UNLOCK(vp);
846 NDINIT_ATVP(&nd, LOOKUP, FOLLOW | LOCKSHARED | LOCKLEAF, UIO_SYSSPACE,
847 "..", vp, td);
848 flags = FREAD;
849 error = vn_open_cred(&nd, &flags, 0, VN_OPEN_NOAUDIT, cred, NULL);
850 if (error) {
851 vn_lock(vp, locked | LK_RETRY);
852 return (error);
853 }
854 NDFREE(&nd, NDF_ONLY_PNBUF);
855
856 mvp = *dvp = nd.ni_vp;
857
858 if (vp->v_mount != (*dvp)->v_mount &&
859 ((*dvp)->v_vflag & VV_ROOT) &&
860 ((*dvp)->v_mount->mnt_flag & MNT_UNION)) {
861 *dvp = (*dvp)->v_mount->mnt_vnodecovered;
862 VREF(mvp);
863 VOP_UNLOCK(mvp);
864 vn_close(mvp, FREAD, cred, td);
865 VREF(*dvp);
866 vn_lock(*dvp, LK_SHARED | LK_RETRY);
867 covered = 1;
868 }
869
870 fileno = va.va_fileid;
871
872 dirbuflen = DEV_BSIZE;
873 if (dirbuflen < va.va_blocksize)
874 dirbuflen = va.va_blocksize;
875 dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK);
876
877 if ((*dvp)->v_type != VDIR) {
878 error = ENOENT;
879 goto out;
880 }
881
882 off = 0;
883 len = 0;
884 do {
885 /* call VOP_READDIR of parent */
886 error = get_next_dirent(*dvp, &dp, dirbuf, dirbuflen, &off,
887 &cpos, &len, &eofflag, td);
888 if (error)
889 goto out;
890
891 if ((dp->d_type != DT_WHT) &&
892 (dp->d_fileno == fileno)) {
893 if (covered) {
894 VOP_UNLOCK(*dvp);
895 vn_lock(mvp, LK_SHARED | LK_RETRY);
896 if (dirent_exists(mvp, dp->d_name, td)) {
897 error = ENOENT;
898 VOP_UNLOCK(mvp);
899 vn_lock(*dvp, LK_SHARED | LK_RETRY);
900 goto out;
901 }
902 VOP_UNLOCK(mvp);
903 vn_lock(*dvp, LK_SHARED | LK_RETRY);
904 }
905 i -= dp->d_namlen;
906
907 if (i < 0) {
908 error = ENOMEM;
909 goto out;
910 }
911 if (dp->d_namlen == 1 && dp->d_name[0] == '.') {
912 error = ENOENT;
913 } else {
914 bcopy(dp->d_name, buf + i, dp->d_namlen);
915 error = 0;
916 }
917 goto out;
918 }
919 } while (len > 0 || !eofflag);
920 error = ENOENT;
921
922 out:
923 free(dirbuf, M_TEMP);
924 if (!error) {
925 *buflen = i;
926 vref(*dvp);
927 }
928 if (covered) {
929 vput(*dvp);
930 vrele(mvp);
931 } else {
932 VOP_UNLOCK(mvp);
933 vn_close(mvp, FREAD, cred, td);
934 }
935 vn_lock(vp, locked | LK_RETRY);
936 return (error);
937 }
938
939 int
940 vop_stdallocate(struct vop_allocate_args *ap)
941 {
942 #ifdef __notyet__
943 struct statfs *sfs;
944 off_t maxfilesize = 0;
945 #endif
946 struct iovec aiov;
947 struct vattr vattr, *vap;
948 struct uio auio;
949 off_t fsize, len, cur, offset;
950 uint8_t *buf;
951 struct thread *td;
952 struct vnode *vp;
953 size_t iosize;
954 int error;
955
956 buf = NULL;
957 error = 0;
958 td = curthread;
959 vap = &vattr;
960 vp = ap->a_vp;
961 len = *ap->a_len;
962 offset = *ap->a_offset;
963
964 error = VOP_GETATTR(vp, vap, ap->a_cred);
965 if (error != 0)
966 goto out;
967 fsize = vap->va_size;
968 iosize = vap->va_blocksize;
969 if (iosize == 0)
970 iosize = BLKDEV_IOSIZE;
971 if (iosize > maxphys)
972 iosize = maxphys;
973 buf = malloc(iosize, M_TEMP, M_WAITOK);
974
975 #ifdef __notyet__
976 /*
977 * Check if the filesystem sets f_maxfilesize; if not use
978 * VOP_SETATTR to perform the check.
979 */
980 sfs = malloc(sizeof(struct statfs), M_STATFS, M_WAITOK);
981 error = VFS_STATFS(vp->v_mount, sfs, td);
982 if (error == 0)
983 maxfilesize = sfs->f_maxfilesize;
984 free(sfs, M_STATFS);
985 if (error != 0)
986 goto out;
987 if (maxfilesize) {
988 if (offset > maxfilesize || len > maxfilesize ||
989 offset + len > maxfilesize) {
990 error = EFBIG;
991 goto out;
992 }
993 } else
994 #endif
995 if (offset + len > vap->va_size) {
996 /*
997 * Test offset + len against the filesystem's maxfilesize.
998 */
999 VATTR_NULL(vap);
1000 vap->va_size = offset + len;
1001 error = VOP_SETATTR(vp, vap, ap->a_cred);
1002 if (error != 0)
1003 goto out;
1004 VATTR_NULL(vap);
1005 vap->va_size = fsize;
1006 error = VOP_SETATTR(vp, vap, ap->a_cred);
1007 if (error != 0)
1008 goto out;
1009 }
1010
1011 for (;;) {
1012 /*
1013 * Read and write back anything below the nominal file
1014 * size. There's currently no way outside the filesystem
1015 * to know whether this area is sparse or not.
1016 */
1017 cur = iosize;
1018 if ((offset % iosize) != 0)
1019 cur -= (offset % iosize);
1020 if (cur > len)
1021 cur = len;
1022 if (offset < fsize) {
1023 aiov.iov_base = buf;
1024 aiov.iov_len = cur;
1025 auio.uio_iov = &aiov;
1026 auio.uio_iovcnt = 1;
1027 auio.uio_offset = offset;
1028 auio.uio_resid = cur;
1029 auio.uio_segflg = UIO_SYSSPACE;
1030 auio.uio_rw = UIO_READ;
1031 auio.uio_td = td;
1032 error = VOP_READ(vp, &auio, ap->a_ioflag, ap->a_cred);
1033 if (error != 0)
1034 break;
1035 if (auio.uio_resid > 0) {
1036 bzero(buf + cur - auio.uio_resid,
1037 auio.uio_resid);
1038 }
1039 } else {
1040 bzero(buf, cur);
1041 }
1042
1043 aiov.iov_base = buf;
1044 aiov.iov_len = cur;
1045 auio.uio_iov = &aiov;
1046 auio.uio_iovcnt = 1;
1047 auio.uio_offset = offset;
1048 auio.uio_resid = cur;
1049 auio.uio_segflg = UIO_SYSSPACE;
1050 auio.uio_rw = UIO_WRITE;
1051 auio.uio_td = td;
1052
1053 error = VOP_WRITE(vp, &auio, ap->a_ioflag, ap->a_cred);
1054 if (error != 0)
1055 break;
1056
1057 len -= cur;
1058 offset += cur;
1059 if (len == 0)
1060 break;
1061 if (should_yield())
1062 break;
1063 }
1064
1065 out:
1066 *ap->a_len = len;
1067 *ap->a_offset = offset;
1068 free(buf, M_TEMP);
1069 return (error);
1070 }
1071
1072 int
1073 vop_stdadvise(struct vop_advise_args *ap)
1074 {
1075 struct vnode *vp;
1076 struct bufobj *bo;
1077 daddr_t startn, endn;
1078 off_t bstart, bend, start, end;
1079 int bsize, error;
1080
1081 vp = ap->a_vp;
1082 switch (ap->a_advice) {
1083 case POSIX_FADV_WILLNEED:
1084 /*
1085 * Do nothing for now. Filesystems should provide a
1086 * custom method which starts an asynchronous read of
1087 * the requested region.
1088 */
1089 error = 0;
1090 break;
1091 case POSIX_FADV_DONTNEED:
1092 error = 0;
1093 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1094 if (VN_IS_DOOMED(vp)) {
1095 VOP_UNLOCK(vp);
1096 break;
1097 }
1098
1099 /*
1100 * Round to block boundaries (and later possibly further to
1101 * page boundaries). Applications cannot reasonably be aware
1102 * of the boundaries, and the rounding must be to expand at
1103 * both extremities to cover enough. It still doesn't cover
1104 * read-ahead. For partial blocks, this gives unnecessary
1105 * discarding of buffers but is efficient enough since the
1106 * pages usually remain in VMIO for some time.
1107 */
1108 bsize = vp->v_bufobj.bo_bsize;
1109 bstart = rounddown(ap->a_start, bsize);
1110 bend = roundup(ap->a_end, bsize);
1111
1112 /*
1113 * Deactivate pages in the specified range from the backing VM
1114 * object. Pages that are resident in the buffer cache will
1115 * remain wired until their corresponding buffers are released
1116 * below.
1117 */
1118 if (vp->v_object != NULL) {
1119 start = trunc_page(bstart);
1120 end = round_page(bend);
1121 VM_OBJECT_RLOCK(vp->v_object);
1122 vm_object_page_noreuse(vp->v_object, OFF_TO_IDX(start),
1123 OFF_TO_IDX(end));
1124 VM_OBJECT_RUNLOCK(vp->v_object);
1125 }
1126
1127 bo = &vp->v_bufobj;
1128 BO_RLOCK(bo);
1129 startn = bstart / bsize;
1130 endn = bend / bsize;
1131 error = bnoreuselist(&bo->bo_clean, bo, startn, endn);
1132 if (error == 0)
1133 error = bnoreuselist(&bo->bo_dirty, bo, startn, endn);
1134 BO_RUNLOCK(bo);
1135 VOP_UNLOCK(vp);
1136 break;
1137 default:
1138 error = EINVAL;
1139 break;
1140 }
1141 return (error);
1142 }
1143
1144 int
1145 vop_stdunp_bind(struct vop_unp_bind_args *ap)
1146 {
1147
1148 ap->a_vp->v_unpcb = ap->a_unpcb;
1149 return (0);
1150 }
1151
1152 int
1153 vop_stdunp_connect(struct vop_unp_connect_args *ap)
1154 {
1155
1156 *ap->a_unpcb = ap->a_vp->v_unpcb;
1157 return (0);
1158 }
1159
1160 int
1161 vop_stdunp_detach(struct vop_unp_detach_args *ap)
1162 {
1163
1164 ap->a_vp->v_unpcb = NULL;
1165 return (0);
1166 }
1167
1168 static int
1169 vop_stdis_text(struct vop_is_text_args *ap)
1170 {
1171
1172 return (ap->a_vp->v_writecount < 0);
1173 }
1174
1175 int
1176 vop_stdset_text(struct vop_set_text_args *ap)
1177 {
1178 struct vnode *vp;
1179 struct mount *mp;
1180 int error, n;
1181
1182 vp = ap->a_vp;
1183
1184 /*
1185 * Avoid the interlock if execs are already present.
1186 */
1187 n = atomic_load_int(&vp->v_writecount);
1188 for (;;) {
1189 if (n > -1) {
1190 break;
1191 }
1192 if (atomic_fcmpset_int(&vp->v_writecount, &n, n - 1)) {
1193 return (0);
1194 }
1195 }
1196
1197 VI_LOCK(vp);
1198 if (vp->v_writecount > 0) {
1199 error = ETXTBSY;
1200 } else {
1201 /*
1202 * If requested by fs, keep a use reference to the
1203 * vnode until the last text reference is released.
1204 */
1205 mp = vp->v_mount;
1206 if (mp != NULL && (mp->mnt_kern_flag & MNTK_TEXT_REFS) != 0 &&
1207 vp->v_writecount == 0) {
1208 VNPASS((vp->v_iflag & VI_TEXT_REF) == 0, vp);
1209 vp->v_iflag |= VI_TEXT_REF;
1210 vrefl(vp);
1211 }
1212
1213 atomic_subtract_int(&vp->v_writecount, 1);
1214 error = 0;
1215 }
1216 VI_UNLOCK(vp);
1217 return (error);
1218 }
1219
1220 static int
1221 vop_stdunset_text(struct vop_unset_text_args *ap)
1222 {
1223 struct vnode *vp;
1224 int error, n;
1225 bool last;
1226
1227 vp = ap->a_vp;
1228
1229 /*
1230 * Avoid the interlock if this is not the last exec.
1231 */
1232 n = atomic_load_int(&vp->v_writecount);
1233 for (;;) {
1234 if (n >= -1) {
1235 break;
1236 }
1237 if (atomic_fcmpset_int(&vp->v_writecount, &n, n + 1)) {
1238 return (0);
1239 }
1240 }
1241
1242 last = false;
1243 VI_LOCK(vp);
1244 if (vp->v_writecount < 0) {
1245 if ((vp->v_iflag & VI_TEXT_REF) != 0 &&
1246 vp->v_writecount == -1) {
1247 last = true;
1248 vp->v_iflag &= ~VI_TEXT_REF;
1249 }
1250 atomic_add_int(&vp->v_writecount, 1);
1251 error = 0;
1252 } else {
1253 error = EINVAL;
1254 }
1255 VI_UNLOCK(vp);
1256 if (last)
1257 vunref(vp);
1258 return (error);
1259 }
1260
1261 static int
1262 vop_stdadd_writecount(struct vop_add_writecount_args *ap)
1263 {
1264 struct vnode *vp;
1265 struct mount *mp;
1266 int error;
1267
1268 vp = ap->a_vp;
1269 VI_LOCK_FLAGS(vp, MTX_DUPOK);
1270 if (vp->v_writecount < 0) {
1271 error = ETXTBSY;
1272 } else {
1273 VNASSERT(vp->v_writecount + ap->a_inc >= 0, vp,
1274 ("neg writecount increment %d", ap->a_inc));
1275 if (vp->v_writecount == 0) {
1276 mp = vp->v_mount;
1277 if (mp != NULL && (mp->mnt_kern_flag & MNTK_NOMSYNC) == 0)
1278 vlazy(vp);
1279 }
1280 vp->v_writecount += ap->a_inc;
1281 error = 0;
1282 }
1283 VI_UNLOCK(vp);
1284 return (error);
1285 }
1286
1287 int
1288 vop_stdneed_inactive(struct vop_need_inactive_args *ap)
1289 {
1290
1291 return (1);
1292 }
1293
1294 int
1295 vop_stdioctl(struct vop_ioctl_args *ap)
1296 {
1297 struct vnode *vp;
1298 struct vattr va;
1299 off_t *offp;
1300 int error;
1301
1302 switch (ap->a_command) {
1303 case FIOSEEKDATA:
1304 case FIOSEEKHOLE:
1305 vp = ap->a_vp;
1306 error = vn_lock(vp, LK_SHARED);
1307 if (error != 0)
1308 return (EBADF);
1309 if (vp->v_type == VREG)
1310 error = VOP_GETATTR(vp, &va, ap->a_cred);
1311 else
1312 error = ENOTTY;
1313 if (error == 0) {
1314 offp = ap->a_data;
1315 if (*offp < 0 || *offp >= va.va_size)
1316 error = ENXIO;
1317 else if (ap->a_command == FIOSEEKHOLE)
1318 *offp = va.va_size;
1319 }
1320 VOP_UNLOCK(vp);
1321 break;
1322 default:
1323 error = ENOTTY;
1324 break;
1325 }
1326 return (error);
1327 }
1328
1329 /*
1330 * vfs default ops
1331 * used to fill the vfs function table to get reasonable default return values.
1332 */
1333 int
1334 vfs_stdroot (mp, flags, vpp)
1335 struct mount *mp;
1336 int flags;
1337 struct vnode **vpp;
1338 {
1339
1340 return (EOPNOTSUPP);
1341 }
1342
1343 int
1344 vfs_stdstatfs (mp, sbp)
1345 struct mount *mp;
1346 struct statfs *sbp;
1347 {
1348
1349 return (EOPNOTSUPP);
1350 }
1351
1352 int
1353 vfs_stdquotactl (mp, cmds, uid, arg)
1354 struct mount *mp;
1355 int cmds;
1356 uid_t uid;
1357 void *arg;
1358 {
1359
1360 return (EOPNOTSUPP);
1361 }
1362
1363 int
1364 vfs_stdsync(mp, waitfor)
1365 struct mount *mp;
1366 int waitfor;
1367 {
1368 struct vnode *vp, *mvp;
1369 struct thread *td;
1370 int error, lockreq, allerror = 0;
1371
1372 td = curthread;
1373 lockreq = LK_EXCLUSIVE | LK_INTERLOCK;
1374 if (waitfor != MNT_WAIT)
1375 lockreq |= LK_NOWAIT;
1376 /*
1377 * Force stale buffer cache information to be flushed.
1378 */
1379 loop:
1380 MNT_VNODE_FOREACH_ALL(vp, mp, mvp) {
1381 if (vp->v_bufobj.bo_dirty.bv_cnt == 0) {
1382 VI_UNLOCK(vp);
1383 continue;
1384 }
1385 if ((error = vget(vp, lockreq)) != 0) {
1386 if (error == ENOENT) {
1387 MNT_VNODE_FOREACH_ALL_ABORT(mp, mvp);
1388 goto loop;
1389 }
1390 continue;
1391 }
1392 error = VOP_FSYNC(vp, waitfor, td);
1393 if (error)
1394 allerror = error;
1395 vput(vp);
1396 }
1397 return (allerror);
1398 }
1399
1400 int
1401 vfs_stdnosync (mp, waitfor)
1402 struct mount *mp;
1403 int waitfor;
1404 {
1405
1406 return (0);
1407 }
1408
1409 static int
1410 vop_stdcopy_file_range(struct vop_copy_file_range_args *ap)
1411 {
1412 int error;
1413
1414 error = vn_generic_copy_file_range(ap->a_invp, ap->a_inoffp,
1415 ap->a_outvp, ap->a_outoffp, ap->a_lenp, ap->a_flags, ap->a_incred,
1416 ap->a_outcred, ap->a_fsizetd);
1417 return (error);
1418 }
1419
1420 int
1421 vfs_stdvget (mp, ino, flags, vpp)
1422 struct mount *mp;
1423 ino_t ino;
1424 int flags;
1425 struct vnode **vpp;
1426 {
1427
1428 return (EOPNOTSUPP);
1429 }
1430
1431 int
1432 vfs_stdfhtovp (mp, fhp, flags, vpp)
1433 struct mount *mp;
1434 struct fid *fhp;
1435 int flags;
1436 struct vnode **vpp;
1437 {
1438
1439 return (EOPNOTSUPP);
1440 }
1441
1442 int
1443 vfs_stdinit (vfsp)
1444 struct vfsconf *vfsp;
1445 {
1446
1447 return (0);
1448 }
1449
1450 int
1451 vfs_stduninit (vfsp)
1452 struct vfsconf *vfsp;
1453 {
1454
1455 return(0);
1456 }
1457
1458 int
1459 vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname)
1460 struct mount *mp;
1461 int cmd;
1462 struct vnode *filename_vp;
1463 int attrnamespace;
1464 const char *attrname;
1465 {
1466
1467 if (filename_vp != NULL)
1468 VOP_UNLOCK(filename_vp);
1469 return (EOPNOTSUPP);
1470 }
1471
1472 int
1473 vfs_stdsysctl(mp, op, req)
1474 struct mount *mp;
1475 fsctlop_t op;
1476 struct sysctl_req *req;
1477 {
1478
1479 return (EOPNOTSUPP);
1480 }
1481
1482 static vop_bypass_t *
1483 bp_by_off(struct vop_vector *vop, struct vop_generic_args *a)
1484 {
1485
1486 return (*(vop_bypass_t **)((char *)vop + a->a_desc->vdesc_vop_offset));
1487 }
1488
1489 int
1490 vop_sigdefer(struct vop_vector *vop, struct vop_generic_args *a)
1491 {
1492 vop_bypass_t *bp;
1493 int prev_stops, rc;
1494
1495 bp = bp_by_off(vop, a);
1496 MPASS(bp != NULL);
1497
1498 prev_stops = sigdeferstop(SIGDEFERSTOP_SILENT);
1499 rc = bp(a);
1500 sigallowstop(prev_stops);
1501 return (rc);
1502 }
1503
1504 static int
1505 vop_stdstat(struct vop_stat_args *a)
1506 {
1507 struct vattr vattr;
1508 struct vattr *vap;
1509 struct vnode *vp;
1510 struct stat *sb;
1511 int error;
1512 u_short mode;
1513
1514 vp = a->a_vp;
1515 sb = a->a_sb;
1516
1517 error = vop_stat_helper_pre(a);
1518 if (error != 0)
1519 return (error);
1520
1521 vap = &vattr;
1522
1523 /*
1524 * Initialize defaults for new and unusual fields, so that file
1525 * systems which don't support these fields don't need to know
1526 * about them.
1527 */
1528 vap->va_birthtime.tv_sec = -1;
1529 vap->va_birthtime.tv_nsec = 0;
1530 vap->va_fsid = VNOVAL;
1531 vap->va_rdev = NODEV;
1532
1533 error = VOP_GETATTR(vp, vap, a->a_active_cred);
1534 if (error)
1535 goto out;
1536
1537 /*
1538 * Zero the spare stat fields
1539 */
1540 bzero(sb, sizeof *sb);
1541
1542 /*
1543 * Copy from vattr table
1544 */
1545 if (vap->va_fsid != VNOVAL)
1546 sb->st_dev = vap->va_fsid;
1547 else
1548 sb->st_dev = vp->v_mount->mnt_stat.f_fsid.val[0];
1549 sb->st_ino = vap->va_fileid;
1550 mode = vap->va_mode;
1551 switch (vap->va_type) {
1552 case VREG:
1553 mode |= S_IFREG;
1554 break;
1555 case VDIR:
1556 mode |= S_IFDIR;
1557 break;
1558 case VBLK:
1559 mode |= S_IFBLK;
1560 break;
1561 case VCHR:
1562 mode |= S_IFCHR;
1563 break;
1564 case VLNK:
1565 mode |= S_IFLNK;
1566 break;
1567 case VSOCK:
1568 mode |= S_IFSOCK;
1569 break;
1570 case VFIFO:
1571 mode |= S_IFIFO;
1572 break;
1573 default:
1574 error = EBADF;
1575 goto out;
1576 }
1577 sb->st_mode = mode;
1578 sb->st_nlink = vap->va_nlink;
1579 sb->st_uid = vap->va_uid;
1580 sb->st_gid = vap->va_gid;
1581 sb->st_rdev = vap->va_rdev;
1582 if (vap->va_size > OFF_MAX) {
1583 error = EOVERFLOW;
1584 goto out;
1585 }
1586 sb->st_size = vap->va_size;
1587 sb->st_atim.tv_sec = vap->va_atime.tv_sec;
1588 sb->st_atim.tv_nsec = vap->va_atime.tv_nsec;
1589 sb->st_mtim.tv_sec = vap->va_mtime.tv_sec;
1590 sb->st_mtim.tv_nsec = vap->va_mtime.tv_nsec;
1591 sb->st_ctim.tv_sec = vap->va_ctime.tv_sec;
1592 sb->st_ctim.tv_nsec = vap->va_ctime.tv_nsec;
1593 sb->st_birthtim.tv_sec = vap->va_birthtime.tv_sec;
1594 sb->st_birthtim.tv_nsec = vap->va_birthtime.tv_nsec;
1595
1596 /*
1597 * According to www.opengroup.org, the meaning of st_blksize is
1598 * "a filesystem-specific preferred I/O block size for this
1599 * object. In some filesystem types, this may vary from file
1600 * to file"
1601 * Use minimum/default of PAGE_SIZE (e.g. for VCHR).
1602 */
1603
1604 sb->st_blksize = max(PAGE_SIZE, vap->va_blocksize);
1605 sb->st_flags = vap->va_flags;
1606 sb->st_blocks = vap->va_bytes / S_BLKSIZE;
1607 sb->st_gen = vap->va_gen;
1608 out:
1609 return (vop_stat_helper_post(a, error));
1610 }
1611
1612 static int
1613 vop_stdread_pgcache(struct vop_read_pgcache_args *ap __unused)
1614 {
1615 return (EJUSTRETURN);
1616 }
1617
1618 static int
1619 vop_stdvput_pair(struct vop_vput_pair_args *ap)
1620 {
1621 struct vnode *dvp, *vp, **vpp;
1622
1623 dvp = ap->a_dvp;
1624 vpp = ap->a_vpp;
1625 vput(dvp);
1626 if (vpp != NULL && ap->a_unlock_vp && (vp = *vpp) != NULL)
1627 vput(vp);
1628 return (0);
1629 }
Cache object: 8bae0e7f5aa26c34f4c8240204f2d13a
|