vfs_default.c revision 135710
1/* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * This code is derived from software contributed 6 * to Berkeley by John Heidemann of the UCLA Ficus project. 7 * 8 * Source: * @(#)i405_init.c 2.10 92/04/27 UCLA Ficus project 9 * 10 * Redistribution and use in source and binary forms, with or without 11 * modification, are permitted provided that the following conditions 12 * are met: 13 * 1. Redistributions of source code must retain the above copyright 14 * notice, this list of conditions and the following disclaimer. 15 * 2. Redistributions in binary form must reproduce the above copyright 16 * notice, this list of conditions and the following disclaimer in the 17 * documentation and/or other materials provided with the distribution. 18 * 4. Neither the name of the University nor the names of its contributors 19 * may be used to endorse or promote products derived from this software 20 * without specific prior written permission. 21 * 22 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 23 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 24 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 25 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 26 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 27 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 28 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 29 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 30 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 31 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35#include <sys/cdefs.h> 36__FBSDID("$FreeBSD: head/sys/kern/vfs_default.c 135710 2004-09-24 06:21:43Z phk $"); 37 38#include <sys/param.h> 39#include <sys/systm.h> 40#include <sys/bio.h> 41#include <sys/buf.h> 42#include <sys/conf.h> 43#include <sys/kernel.h> 44#include <sys/limits.h> 45#include <sys/lock.h> 46#include <sys/malloc.h> 47#include <sys/mount.h> 48#include <sys/mutex.h> 49#include <sys/unistd.h> 50#include <sys/vnode.h> 51#include <sys/poll.h> 52 53#include <vm/vm.h> 54#include <vm/vm_object.h> 55#include <vm/vm_extern.h> 56#include <vm/pmap.h> 57#include <vm/vm_map.h> 58#include <vm/vm_page.h> 59#include <vm/vm_pager.h> 60#include <vm/vnode_pager.h> 61 62static int vop_nolookup(struct vop_lookup_args *); 63static int vop_nostrategy(struct vop_strategy_args *); 64 65/* 66 * This vnode table stores what we want to do if the filesystem doesn't 67 * implement a particular VOP. 68 * 69 * If there is no specific entry here, we will return EOPNOTSUPP. 70 * 71 */ 72 73vop_t **default_vnodeop_p; 74static struct vnodeopv_entry_desc default_vnodeop_entries[] = { 75 { &vop_default_desc, (vop_t *) vop_eopnotsupp }, 76 { &vop_advlock_desc, (vop_t *) vop_einval }, 77 { &vop_bmap_desc, (vop_t *) vop_stdbmap }, 78 { &vop_close_desc, (vop_t *) vop_null }, 79 { &vop_createvobject_desc, (vop_t *) vop_stdcreatevobject }, 80 { &vop_destroyvobject_desc, (vop_t *) vop_stddestroyvobject }, 81 { &vop_fsync_desc, (vop_t *) vop_null }, 82 { &vop_getpages_desc, (vop_t *) vop_stdgetpages }, 83 { &vop_getvobject_desc, (vop_t *) vop_stdgetvobject }, 84 { &vop_inactive_desc, (vop_t *) vop_stdinactive }, 85 { &vop_ioctl_desc, (vop_t *) vop_enotty }, 86 { &vop_islocked_desc, (vop_t *) vop_stdislocked }, 87 { &vop_lease_desc, (vop_t *) vop_null }, 88 { &vop_lock_desc, (vop_t *) vop_stdlock }, 89 { &vop_lookup_desc, (vop_t *) vop_nolookup }, 90 { &vop_open_desc, (vop_t *) vop_null }, 91 { &vop_pathconf_desc, (vop_t *) vop_einval }, 92 { &vop_poll_desc, (vop_t *) vop_nopoll }, 93 { &vop_putpages_desc, (vop_t *) vop_stdputpages }, 94 { &vop_readlink_desc, (vop_t *) vop_einval }, 95 { &vop_revoke_desc, (vop_t *) vop_revoke }, 96 { &vop_specstrategy_desc, (vop_t *) vop_panic }, 97 { &vop_strategy_desc, (vop_t *) vop_nostrategy }, 98 { &vop_unlock_desc, (vop_t *) vop_stdunlock }, 99 { NULL, NULL } 100}; 101 102static struct vnodeopv_desc default_vnodeop_opv_desc = 103 { &default_vnodeop_p, default_vnodeop_entries }; 104 105VNODEOP_SET(default_vnodeop_opv_desc); 106 107/* 108 * Series of placeholder functions for various error returns for 109 * VOPs. 110 */ 111 112int 113vop_eopnotsupp(struct vop_generic_args *ap) 114{ 115 /* 116 printf("vop_notsupp[%s]\n", ap->a_desc->vdesc_name); 117 */ 118 119 return (EOPNOTSUPP); 120} 121 122int 123vop_ebadf(struct vop_generic_args *ap) 124{ 125 126 return (EBADF); 127} 128 129int 130vop_enotty(struct vop_generic_args *ap) 131{ 132 133 return (ENOTTY); 134} 135 136int 137vop_einval(struct vop_generic_args *ap) 138{ 139 140 return (EINVAL); 141} 142 143int 144vop_null(struct vop_generic_args *ap) 145{ 146 147 return (0); 148} 149 150/* 151 * Used to make a defined VOP fall back to the default VOP. 152 */ 153int 154vop_defaultop(struct vop_generic_args *ap) 155{ 156 157 return (VOCALL(default_vnodeop_p, ap->a_desc->vdesc_offset, ap)); 158} 159 160/* 161 * Helper function to panic on some bad VOPs in some filesystems. 162 */ 163int 164vop_panic(struct vop_generic_args *ap) 165{ 166 167 panic("filesystem goof: vop_panic[%s]", ap->a_desc->vdesc_name); 168} 169 170/* 171 * vop_std<something> and vop_no<something> are default functions for use by 172 * filesystems that need the "default reasonable" implementation for a 173 * particular operation. 174 * 175 * The documentation for the operations they implement exists (if it exists) 176 * in the VOP_<SOMETHING>(9) manpage (all uppercase). 177 */ 178 179/* 180 * Default vop for filesystems that do not support name lookup 181 */ 182static int 183vop_nolookup(ap) 184 struct vop_lookup_args /* { 185 struct vnode *a_dvp; 186 struct vnode **a_vpp; 187 struct componentname *a_cnp; 188 } */ *ap; 189{ 190 191 *ap->a_vpp = NULL; 192 return (ENOTDIR); 193} 194 195/* 196 * vop_nostrategy: 197 * 198 * Strategy routine for VFS devices that have none. 199 * 200 * BIO_ERROR and B_INVAL must be cleared prior to calling any strategy 201 * routine. Typically this is done for a BIO_READ strategy call. 202 * Typically B_INVAL is assumed to already be clear prior to a write 203 * and should not be cleared manually unless you just made the buffer 204 * invalid. BIO_ERROR should be cleared either way. 205 */ 206 207static int 208vop_nostrategy (struct vop_strategy_args *ap) 209{ 210 KASSERT(ap->a_vp == ap->a_bp->b_vp, ("%s(%p != %p)", 211 __func__, ap->a_vp, ap->a_bp->b_vp)); 212 printf("No strategy for buffer at %p\n", ap->a_bp); 213 vprint("vnode", ap->a_vp); 214 vprint("device vnode", ap->a_bp->b_vp); 215 ap->a_bp->b_ioflags |= BIO_ERROR; 216 ap->a_bp->b_error = EOPNOTSUPP; 217 bufdone(ap->a_bp); 218 return (EOPNOTSUPP); 219} 220 221/* 222 * vop_stdpathconf: 223 * 224 * Standard implementation of POSIX pathconf, to get information about limits 225 * for a filesystem. 226 * Override per filesystem for the case where the filesystem has smaller 227 * limits. 228 */ 229int 230vop_stdpathconf(ap) 231 struct vop_pathconf_args /* { 232 struct vnode *a_vp; 233 int a_name; 234 int *a_retval; 235 } */ *ap; 236{ 237 238 switch (ap->a_name) { 239 case _PC_LINK_MAX: 240 *ap->a_retval = LINK_MAX; 241 return (0); 242 case _PC_MAX_CANON: 243 *ap->a_retval = MAX_CANON; 244 return (0); 245 case _PC_MAX_INPUT: 246 *ap->a_retval = MAX_INPUT; 247 return (0); 248 case _PC_PIPE_BUF: 249 *ap->a_retval = PIPE_BUF; 250 return (0); 251 case _PC_CHOWN_RESTRICTED: 252 *ap->a_retval = 1; 253 return (0); 254 case _PC_VDISABLE: 255 *ap->a_retval = _POSIX_VDISABLE; 256 return (0); 257 default: 258 return (EINVAL); 259 } 260 /* NOTREACHED */ 261} 262 263/* 264 * Standard lock, unlock and islocked functions. 265 */ 266int 267vop_stdlock(ap) 268 struct vop_lock_args /* { 269 struct vnode *a_vp; 270 int a_flags; 271 struct thread *a_td; 272 } */ *ap; 273{ 274 struct vnode *vp = ap->a_vp; 275 276#ifndef DEBUG_LOCKS 277 return (lockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), ap->a_td)); 278#else 279 return (debuglockmgr(vp->v_vnlock, ap->a_flags, VI_MTX(vp), 280 ap->a_td, "vop_stdlock", vp->filename, vp->line)); 281#endif 282} 283 284/* See above. */ 285int 286vop_stdunlock(ap) 287 struct vop_unlock_args /* { 288 struct vnode *a_vp; 289 int a_flags; 290 struct thread *a_td; 291 } */ *ap; 292{ 293 struct vnode *vp = ap->a_vp; 294 295 return (lockmgr(vp->v_vnlock, ap->a_flags | LK_RELEASE, VI_MTX(vp), 296 ap->a_td)); 297} 298 299/* See above. */ 300int 301vop_stdislocked(ap) 302 struct vop_islocked_args /* { 303 struct vnode *a_vp; 304 struct thread *a_td; 305 } */ *ap; 306{ 307 308 return (lockstatus(ap->a_vp->v_vnlock, ap->a_td)); 309} 310 311/* Mark the vnode inactive */ 312int 313vop_stdinactive(ap) 314 struct vop_inactive_args /* { 315 struct vnode *a_vp; 316 struct thread *a_td; 317 } */ *ap; 318{ 319 320 VOP_UNLOCK(ap->a_vp, 0, ap->a_td); 321 return (0); 322} 323 324/* 325 * Return true for select/poll. 326 */ 327int 328vop_nopoll(ap) 329 struct vop_poll_args /* { 330 struct vnode *a_vp; 331 int a_events; 332 struct ucred *a_cred; 333 struct thread *a_td; 334 } */ *ap; 335{ 336 /* 337 * Return true for read/write. If the user asked for something 338 * special, return POLLNVAL, so that clients have a way of 339 * determining reliably whether or not the extended 340 * functionality is present without hard-coding knowledge 341 * of specific filesystem implementations. 342 * Stay in sync with kern_conf.c::no_poll(). 343 */ 344 if (ap->a_events & ~POLLSTANDARD) 345 return (POLLNVAL); 346 347 return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)); 348} 349 350/* 351 * Implement poll for local filesystems that support it. 352 */ 353int 354vop_stdpoll(ap) 355 struct vop_poll_args /* { 356 struct vnode *a_vp; 357 int a_events; 358 struct ucred *a_cred; 359 struct thread *a_td; 360 } */ *ap; 361{ 362 if (ap->a_events & ~POLLSTANDARD) 363 return (vn_pollrecord(ap->a_vp, ap->a_td, ap->a_events)); 364 return (ap->a_events & (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)); 365} 366 367/* 368 * Return our mount point, as we will take charge of the writes. 369 */ 370int 371vop_stdgetwritemount(ap) 372 struct vop_getwritemount_args /* { 373 struct vnode *a_vp; 374 struct mount **a_mpp; 375 } */ *ap; 376{ 377 378 *(ap->a_mpp) = ap->a_vp->v_mount; 379 return (0); 380} 381 382/* Create the VM system backing object for this vnode */ 383int 384vop_stdcreatevobject(ap) 385 struct vop_createvobject_args /* { 386 struct vnode *vp; 387 struct ucred *cred; 388 struct thread *td; 389 } */ *ap; 390{ 391 struct vnode *vp = ap->a_vp; 392 struct ucred *cred = ap->a_cred; 393 struct thread *td = ap->a_td; 394 struct vattr vat; 395 vm_object_t object; 396 int error = 0; 397 398 GIANT_REQUIRED; 399 400 if (!vn_isdisk(vp, NULL) && vn_canvmio(vp) == FALSE) 401 return (0); 402 403retry: 404 if ((object = vp->v_object) == NULL) { 405 if (vp->v_type == VREG || vp->v_type == VDIR) { 406 if ((error = VOP_GETATTR(vp, &vat, cred, td)) != 0) 407 goto retn; 408 object = vnode_pager_alloc(vp, vat.va_size, 0, 0); 409 } else if (vn_isdisk(vp)) { 410 /* 411 * This simply allocates the biggest object possible 412 * for a disk vnode. This should be fixed, but doesn't 413 * cause any problems (yet). 414 */ 415 object = vnode_pager_alloc(vp, IDX_TO_OFF(INT_MAX), 0, 0); 416 } else { 417 goto retn; 418 } 419 /* 420 * Dereference the reference we just created. This assumes 421 * that the object is associated with the vp. 422 */ 423 VM_OBJECT_LOCK(object); 424 object->ref_count--; 425 VM_OBJECT_UNLOCK(object); 426 vrele(vp); 427 } else { 428 VM_OBJECT_LOCK(object); 429 if (object->flags & OBJ_DEAD) { 430 VOP_UNLOCK(vp, 0, td); 431 msleep(object, VM_OBJECT_MTX(object), PDROP | PVM, 432 "vodead", 0); 433 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, td); 434 goto retry; 435 } 436 VM_OBJECT_UNLOCK(object); 437 } 438 439 KASSERT(vp->v_object != NULL, ("vfs_object_create: NULL object")); 440 vp->v_vflag |= VV_OBJBUF; 441 442retn: 443 return (error); 444} 445 446/* Destroy the VM system object associated with this vnode */ 447int 448vop_stddestroyvobject(ap) 449 struct vop_destroyvobject_args /* { 450 struct vnode *vp; 451 } */ *ap; 452{ 453 struct vnode *vp = ap->a_vp; 454 vm_object_t obj = vp->v_object; 455 456 GIANT_REQUIRED; 457 458 if (obj == NULL) 459 return (0); 460 VM_OBJECT_LOCK(obj); 461 if (obj->ref_count == 0) { 462 /* 463 * vclean() may be called twice. The first time 464 * removes the primary reference to the object, 465 * the second time goes one further and is a 466 * special-case to terminate the object. 467 * 468 * don't double-terminate the object 469 */ 470 if ((obj->flags & OBJ_DEAD) == 0) 471 vm_object_terminate(obj); 472 else 473 VM_OBJECT_UNLOCK(obj); 474 } else { 475 /* 476 * Woe to the process that tries to page now :-). 477 */ 478 vm_pager_deallocate(obj); 479 VM_OBJECT_UNLOCK(obj); 480 } 481 return (0); 482} 483 484/* 485 * Return the underlying VM object. This routine may be called with or 486 * without the vnode interlock held. If called without, the returned 487 * object is not guarenteed to be valid. The syncer typically gets the 488 * object without holding the interlock in order to quickly test whether 489 * it might be dirty before going heavy-weight. vm_object's use zalloc 490 * and thus stable-storage, so this is safe. 491 */ 492int 493vop_stdgetvobject(ap) 494 struct vop_getvobject_args /* { 495 struct vnode *vp; 496 struct vm_object **objpp; 497 } */ *ap; 498{ 499 struct vnode *vp = ap->a_vp; 500 struct vm_object **objpp = ap->a_objpp; 501 502 if (objpp) 503 *objpp = vp->v_object; 504 return (vp->v_object ? 0 : EINVAL); 505} 506 507/* XXX Needs good comment and VOP_BMAP(9) manpage */ 508int 509vop_stdbmap(ap) 510 struct vop_bmap_args /* { 511 struct vnode *a_vp; 512 daddr_t a_bn; 513 struct vnode **a_vpp; 514 daddr_t *a_bnp; 515 int *a_runp; 516 int *a_runb; 517 } */ *ap; 518{ 519 520 if (ap->a_vpp != NULL) 521 *ap->a_vpp = ap->a_vp; 522 if (ap->a_bnp != NULL) 523 *ap->a_bnp = ap->a_bn * btodb(ap->a_vp->v_mount->mnt_stat.f_iosize); 524 if (ap->a_runp != NULL) 525 *ap->a_runp = 0; 526 if (ap->a_runb != NULL) 527 *ap->a_runb = 0; 528 return (0); 529} 530 531int 532vop_stdfsync(ap) 533 struct vop_fsync_args /* { 534 struct vnode *a_vp; 535 struct ucred *a_cred; 536 int a_waitfor; 537 struct thread *a_td; 538 } */ *ap; 539{ 540 struct vnode *vp = ap->a_vp; 541 struct buf *bp; 542 struct buf *nbp; 543 int s, error = 0; 544 int maxretry = 100; /* large, arbitrarily chosen */ 545 546 VI_LOCK(vp); 547loop1: 548 /* 549 * MARK/SCAN initialization to avoid infinite loops. 550 */ 551 s = splbio(); 552 TAILQ_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) { 553 bp->b_vflags &= ~BV_SCANNED; 554 bp->b_error = 0; 555 } 556 splx(s); 557 558 /* 559 * Flush all dirty buffers associated with a block device. 560 */ 561loop2: 562 s = splbio(); 563 for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp != NULL; bp = nbp) { 564 nbp = TAILQ_NEXT(bp, b_vnbufs); 565 if ((bp->b_vflags & BV_SCANNED) != 0) 566 continue; 567 bp->b_vflags |= BV_SCANNED; 568 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) 569 continue; 570 VI_UNLOCK(vp); 571 if ((bp->b_flags & B_DELWRI) == 0) 572 panic("fsync: not dirty"); 573 if ((vp->v_vflag & VV_OBJBUF) && (bp->b_flags & B_CLUSTEROK)) { 574 vfs_bio_awrite(bp); 575 splx(s); 576 } else { 577 bremfree(bp); 578 splx(s); 579 bawrite(bp); 580 } 581 VI_LOCK(vp); 582 goto loop2; 583 } 584 585 /* 586 * If synchronous the caller expects us to completely resolve all 587 * dirty buffers in the system. Wait for in-progress I/O to 588 * complete (which could include background bitmap writes), then 589 * retry if dirty blocks still exist. 590 */ 591 if (ap->a_waitfor == MNT_WAIT) { 592 while (vp->v_numoutput) { 593 vp->v_iflag |= VI_BWAIT; 594 msleep((caddr_t)&vp->v_numoutput, VI_MTX(vp), 595 PRIBIO + 1, "fsync", 0); 596 } 597 if (!TAILQ_EMPTY(&vp->v_dirtyblkhd)) { 598 /* 599 * If we are unable to write any of these buffers 600 * then we fail now rather than trying endlessly 601 * to write them out. 602 */ 603 TAILQ_FOREACH(bp, &vp->v_dirtyblkhd, b_vnbufs) 604 if ((error = bp->b_error) == 0) 605 continue; 606 if (error == 0 && --maxretry >= 0) { 607 splx(s); 608 goto loop1; 609 } 610 vprint("fsync: giving up on dirty", vp); 611 error = EAGAIN; 612 } 613 } 614 VI_UNLOCK(vp); 615 splx(s); 616 617 return (error); 618} 619 620/* XXX Needs good comment and more info in the manpage (VOP_GETPAGES(9)). */ 621int 622vop_stdgetpages(ap) 623 struct vop_getpages_args /* { 624 struct vnode *a_vp; 625 vm_page_t *a_m; 626 int a_count; 627 int a_reqpage; 628 vm_ooffset_t a_offset; 629 } */ *ap; 630{ 631 632 return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, 633 ap->a_count, ap->a_reqpage); 634} 635 636/* XXX Needs good comment and more info in the manpage (VOP_PUTPAGES(9)). */ 637int 638vop_stdputpages(ap) 639 struct vop_putpages_args /* { 640 struct vnode *a_vp; 641 vm_page_t *a_m; 642 int a_count; 643 int a_sync; 644 int *a_rtvals; 645 vm_ooffset_t a_offset; 646 } */ *ap; 647{ 648 649 return vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count, 650 ap->a_sync, ap->a_rtvals); 651} 652 653/* 654 * vfs default ops 655 * used to fill the vfs function table to get reasonable default return values. 656 */ 657int 658vfs_stdroot (mp, vpp, td) 659 struct mount *mp; 660 struct vnode **vpp; 661 struct thread *td; 662{ 663 664 return (EOPNOTSUPP); 665} 666 667int 668vfs_stdstatfs (mp, sbp, td) 669 struct mount *mp; 670 struct statfs *sbp; 671 struct thread *td; 672{ 673 674 return (EOPNOTSUPP); 675} 676 677int 678vfs_stdvptofh (vp, fhp) 679 struct vnode *vp; 680 struct fid *fhp; 681{ 682 683 return (EOPNOTSUPP); 684} 685 686int 687vfs_stdstart (mp, flags, td) 688 struct mount *mp; 689 int flags; 690 struct thread *td; 691{ 692 693 return (0); 694} 695 696int 697vfs_stdquotactl (mp, cmds, uid, arg, td) 698 struct mount *mp; 699 int cmds; 700 uid_t uid; 701 caddr_t arg; 702 struct thread *td; 703{ 704 705 return (EOPNOTSUPP); 706} 707 708int 709vfs_stdsync(mp, waitfor, cred, td) 710 struct mount *mp; 711 int waitfor; 712 struct ucred *cred; 713 struct thread *td; 714{ 715 struct vnode *vp, *nvp; 716 int error, lockreq, allerror = 0; 717 718 lockreq = LK_EXCLUSIVE | LK_INTERLOCK; 719 if (waitfor != MNT_WAIT) 720 lockreq |= LK_NOWAIT; 721 /* 722 * Force stale buffer cache information to be flushed. 723 */ 724 MNT_ILOCK(mp); 725loop: 726 MNT_VNODE_FOREACH(vp, mp, nvp) { 727 728 VI_LOCK(vp); 729 if (TAILQ_EMPTY(&vp->v_dirtyblkhd)) { 730 VI_UNLOCK(vp); 731 continue; 732 } 733 MNT_IUNLOCK(mp); 734 735 if ((error = vget(vp, lockreq, td)) != 0) { 736 MNT_ILOCK(mp); 737 if (error == ENOENT) 738 goto loop; 739 continue; 740 } 741 error = VOP_FSYNC(vp, cred, waitfor, td); 742 if (error) 743 allerror = error; 744 745 VOP_UNLOCK(vp, 0, td); 746 vrele(vp); 747 MNT_ILOCK(mp); 748 } 749 MNT_IUNLOCK(mp); 750 return (allerror); 751} 752 753int 754vfs_stdnosync (mp, waitfor, cred, td) 755 struct mount *mp; 756 int waitfor; 757 struct ucred *cred; 758 struct thread *td; 759{ 760 761 return (0); 762} 763 764int 765vfs_stdvget (mp, ino, flags, vpp) 766 struct mount *mp; 767 ino_t ino; 768 int flags; 769 struct vnode **vpp; 770{ 771 772 return (EOPNOTSUPP); 773} 774 775int 776vfs_stdfhtovp (mp, fhp, vpp) 777 struct mount *mp; 778 struct fid *fhp; 779 struct vnode **vpp; 780{ 781 782 return (EOPNOTSUPP); 783} 784 785int 786vfs_stdinit (vfsp) 787 struct vfsconf *vfsp; 788{ 789 790 return (0); 791} 792 793int 794vfs_stduninit (vfsp) 795 struct vfsconf *vfsp; 796{ 797 798 return(0); 799} 800 801int 802vfs_stdextattrctl(mp, cmd, filename_vp, attrnamespace, attrname, td) 803 struct mount *mp; 804 int cmd; 805 struct vnode *filename_vp; 806 int attrnamespace; 807 const char *attrname; 808 struct thread *td; 809{ 810 811 if (filename_vp != NULL) 812 VOP_UNLOCK(filename_vp, 0, td); 813 return (EOPNOTSUPP); 814} 815 816int 817vfs_stdsysctl(mp, op, req) 818 struct mount *mp; 819 fsctlop_t op; 820 struct sysctl_req *req; 821{ 822 823 return (EOPNOTSUPP); 824} 825 826/* end of vfs default ops */ 827