1 /* 2 * Copyright (c) 1989, 1993 3 * The Regents of the University of California. All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 3. All advertising materials mentioning features or use of this software 14 * must display the following acknowledgement: 15 * This product includes software developed by the University of 16 * California, Berkeley and its contributors. 17 * 4. Neither the name of the University nor the names of its contributors 18 * may be used to endorse or promote products derived from this software 19 * without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 22 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 24 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 25 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 26 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 27 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 28 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 29 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 30 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 31 * SUCH DAMAGE. 32 * 33 * @(#)vnode.h 8.7 (Berkeley) 2/4/94 34 * $FreeBSD: src/sys/sys/vnode.h,v 1.111.2.19 2002/12/29 18:19:53 dillon Exp $ 35 * $DragonFly: src/sys/sys/vnode.h,v 1.28 2004/12/17 00:18:09 dillon Exp $ 36 */ 37 38 #ifndef _SYS_VNODE_H_ 39 #define _SYS_VNODE_H_ 40 41 #include <sys/queue.h> 42 #include <sys/lock.h> 43 #include <sys/select.h> 44 #include <sys/uio.h> 45 #include <sys/acl.h> 46 #include <sys/namecache.h> 47 #if defined(_KERNEL) || defined(_KERNEL_STRUCTURES) 48 #include <sys/thread.h> 49 #endif 50 #include <sys/vfsops.h> 51 #include <sys/vfscache.h> 52 53 #include <machine/lock.h> 54 55 /* 56 * The vnode is the focus of all file activity in UNIX. There is a 57 * unique vnode allocated for each active file, each current directory, 58 * each mounted-on file, text file, and the root. 59 */ 60 61 /* 62 * Each underlying filesystem allocates its own private area and hangs 63 * it from v_data. If non-null, this area is freed in getnewvnode(). 64 */ 65 TAILQ_HEAD(buflists, buf); 66 67 /* 68 * Range locks protect offset ranges in files and directories at a high 69 * level, allowing the actual I/O to be broken down into smaller pieces. 70 * Range locks will eventually be integrated into the clustered cache 71 * coherency infrastructure. 72 * 73 * We use a simple data structure for now, but eventually this should 74 * probably be a btree or red-black tree. 75 */ 76 struct vrangelock; 77 78 TAILQ_HEAD(vrangelock_list, vrangelock); 79 80 struct vrangehead { 81 struct vrangelock_list vh_list; 82 }; 83 84 struct vrangelock { 85 TAILQ_ENTRY(vrangelock) vr_node; 86 int vr_flags; 87 off_t vr_offset; 88 off_t vr_length; 89 }; 90 91 #define RNGL_WAITING 0x0001 /* waiting for lock, else has lock */ 92 #define RNGL_CHECK 0x0002 /* check for work on unlock */ 93 #define RNGL_SHARED 0x0004 /* shared lock, else exclusive */ 94 #define RNGL_ONLIST 0x0008 /* sanity check */ 95 96 static __inline 97 void 98 vrange_init(struct vrangelock *vr, int flags, off_t offset, off_t length) 99 { 100 vr->vr_flags = flags; 101 vr->vr_offset = offset; 102 vr->vr_length = length; 103 } 104 105 #ifdef _KERNEL 106 107 void vrange_lock(struct vnode *vp, struct vrangelock *vr); 108 void vrange_unlock(struct vnode *vp, struct vrangelock *vr); 109 110 static __inline 111 void 112 vrange_lock_shared(struct vnode *vp, struct vrangelock *vr, 113 off_t offset, off_t length) 114 { 115 vrange_init(vr, RNGL_SHARED, offset, length); 116 vrange_lock(vp, vr); 117 } 118 119 static __inline 120 void 121 vrange_lock_excl(struct vnode *vp, struct vrangelock *vr, 122 off_t offset, off_t length) 123 { 124 vrange_init(vr, 0, offset, length); 125 vrange_lock(vp, vr); 126 } 127 128 #endif 129 130 /* 131 * The vnode infrastructure is being reorgranized. Most reference-related 132 * fields are locked by the BGL, and most file I/O related operations and 133 * vnode teardown functions are locked by the vnode lock. 134 * 135 * File read operations require a shared lock, file write operations require 136 * an exclusive lock. Most directory operations (read or write) currently 137 * require an exclusive lock due to the side effects stored in the directory 138 * inode (which we intend to fix). 139 * 140 * File reads and writes are further protected by a range lock. The intention 141 * is to be able to break I/O operations down into more easily managed pieces 142 * so vm_page arrays can be passed through rather then UIOs. This work will 143 * occur in multiple stages. The range locks will also eventually be used to 144 * deal with clustered cache coherency issues and, more immediately, to 145 * protect operations associated with the kernel-managed journaling module. 146 * 147 * NOTE: XXX v_opencount currently only used by specfs. It should be used 148 * universally. 149 * 150 * NOTE: The vnode operations vector, v_ops, is a double-indirect that 151 * typically points to &v_mount->mnt_vn_use_ops. We use a double 152 * pointer because mnt_vn_use_ops may change dynamically when e.g. 153 * journaling is turned on or off. 154 */ 155 struct vnode { 156 u_long v_flag; /* vnode flags (see below) */ 157 int v_usecount; /* reference count of users */ 158 int v_writecount; /* reference count of writers */ 159 int v_holdcnt; /* page & buffer references */ 160 int v_opencount; /* number of explicit opens */ 161 u_long v_id; /* capability identifier */ 162 struct mount *v_mount; /* ptr to vfs we are in */ 163 struct vop_ops **v_ops; /* vnode operations vector */ 164 TAILQ_ENTRY(vnode) v_freelist; /* vnode freelist */ 165 TAILQ_ENTRY(vnode) v_nmntvnodes; /* vnodes for mount point */ 166 struct buflists v_cleanblkhd; /* clean blocklist head */ 167 struct buflists v_dirtyblkhd; /* dirty blocklist head */ 168 LIST_ENTRY(vnode) v_synclist; /* vnodes with dirty buffers */ 169 long v_numoutput; /* num of writes in progress */ 170 enum vtype v_type; /* vnode type */ 171 union { 172 struct mount *vu_mountedhere;/* ptr to mounted vfs (VDIR) */ 173 struct socket *vu_socket; /* unix ipc (VSOCK) */ 174 struct { 175 udev_t vu_udev; /* device number for attach */ 176 struct specinfo *vu_specinfo; /* device (VCHR, VBLK) */ 177 SLIST_ENTRY(vnode) vu_specnext; 178 } vu_spec; 179 struct fifoinfo *vu_fifoinfo; /* fifo (VFIFO) */ 180 } v_un; 181 struct nqlease *v_lease; /* Soft reference to lease */ 182 daddr_t v_lastw; /* last write (write cluster) */ 183 daddr_t v_cstart; /* start block of cluster */ 184 daddr_t v_lasta; /* last allocation */ 185 int v_clen; /* length of current cluster */ 186 struct vm_object *v_object; /* Place to store VM object */ 187 struct lock v_lock; /* file/dir ops lock */ 188 enum vtagtype v_tag; /* type of underlying data */ 189 void *v_data; /* private data for fs */ 190 struct namecache_list v_namecache; /* associated nc entries */ 191 struct { 192 struct lwkt_token vpi_token; /* lock to protect below */ 193 struct selinfo vpi_selinfo; /* identity of poller(s) */ 194 short vpi_events; /* what they are looking for */ 195 short vpi_revents; /* what has happened */ 196 } v_pollinfo; 197 struct vmresident *v_resident; /* optional vmresident */ 198 struct vrangehead v_range; /* range lock */ 199 #ifdef DEBUG_LOCKS 200 const char *filename; /* Source file doing locking */ 201 int line; /* Line number doing locking */ 202 #endif 203 void *v_xaddr; 204 }; 205 #define v_mountedhere v_un.vu_mountedhere 206 #define v_socket v_un.vu_socket 207 #define v_udev v_un.vu_spec.vu_udev 208 #define v_rdev v_un.vu_spec.vu_specinfo 209 #define v_specnext v_un.vu_spec.vu_specnext 210 #define v_fifoinfo v_un.vu_fifoinfo 211 212 #define VN_POLLEVENT(vp, events) \ 213 do { \ 214 if ((vp)->v_pollinfo.vpi_events & (events)) \ 215 vn_pollevent((vp), (events)); \ 216 } while (0) 217 218 /* 219 * Vnode flags. 220 */ 221 #define VROOT 0x00001 /* root of its file system */ 222 #define VTEXT 0x00002 /* vnode is a pure text prototype */ 223 #define VSYSTEM 0x00004 /* vnode being used by kernel */ 224 #define VISTTY 0x00008 /* vnode represents a tty */ 225 #define VCTTYISOPEN 0x00010 /* controlling terminal tty is open */ 226 #define VCKPT 0x00020 /* checkpoint-restored vnode */ 227 /* open for business 0x00040 */ 228 /* open for business 0x00080 */ 229 /* open for business 0x00100 */ 230 /* open for business 0x00200 */ 231 #define VBWAIT 0x00400 /* waiting for output to complete */ 232 /* open for business 0x00800 */ 233 /* open for business 0x01000 */ 234 #define VOBJBUF 0x02000 /* Allocate buffers in VM object */ 235 #define VINACTIVE 0x04000 /* The vnode is inactive */ 236 #define VAGE 0x08000 /* Insert vnode at head of free list */ 237 #define VOLOCK 0x10000 /* vnode is locked waiting for an object */ 238 #define VOWANT 0x20000 /* a process is waiting for VOLOCK */ 239 #define VRECLAIMED 0x40000 /* This vnode has been destroyed */ 240 #define VFREE 0x80000 /* This vnode is on the freelist */ 241 /* open for business 0x100000 */ 242 #define VONWORKLST 0x200000 /* On syncer work-list */ 243 #define VMOUNT 0x400000 /* Mount in progress */ 244 #define VOBJDIRTY 0x800000 /* object might be dirty */ 245 #define VPLACEMARKER 0x1000000 /* dummy vnode placemarker */ 246 247 /* 248 * vmntvnodescan() flags 249 */ 250 #define VMSC_GETVP 1 251 #define VMSC_GETVX 2 252 #define VMSC_REFVP 3 253 #define VMSC_NOWAIT 0x10 254 255 /* 256 * Flags for ioflag. (high 16 bits used to ask for read-ahead and 257 * help with write clustering) 258 */ 259 #define IO_UNIT 0x0001 /* do I/O as atomic unit */ 260 #define IO_APPEND 0x0002 /* append write to end */ 261 #define IO_SYNC 0x0004 /* do I/O synchronously */ 262 #define IO_NODELOCKED 0x0008 /* underlying node already locked */ 263 #define IO_NDELAY 0x0010 /* FNDELAY flag set in file table */ 264 #define IO_VMIO 0x0020 /* data already in VMIO space */ 265 #define IO_INVAL 0x0040 /* invalidate after I/O */ 266 #define IO_ASYNC 0x0080 /* bawrite rather then bdwrite */ 267 #define IO_DIRECT 0x0100 /* attempt to bypass buffer cache */ 268 #define IO_NOWDRAIN 0x0200 /* do not block on wdrain */ 269 #define IO_CORE 0x0400 /* I/O is part of core dump */ 270 271 #define IO_SEQMAX 0x7F /* seq heuristic max value */ 272 #define IO_SEQSHIFT 16 /* seq heuristic in upper 16 bits */ 273 274 /* 275 * Modes. Note that these V-modes must match file S_I*USR, SUID, SGID, 276 * and SVTX flag bits. 277 * 278 * VCREATE, VDELETE, and VEXCL may only be used in naccess() calls. 279 */ 280 #define VDELETE 040000 /* delete if the file/dir exists */ 281 #define VCREATE 020000 /* create if the file/dir does not exist */ 282 #define VEXCL 010000 /* error if the file/dir already exists */ 283 284 #define VSUID 04000 /* set user id on execution */ 285 #define VSGID 02000 /* set group id on execution */ 286 #define VSVTX 01000 /* save swapped text even after use */ 287 #define VREAD 00400 /* read, write, execute permissions */ 288 #define VWRITE 00200 289 #define VEXEC 00100 290 291 /* 292 * Token indicating no attribute value yet assigned. 293 */ 294 #define VNOVAL (-1) 295 296 /* 297 * LK_TIMELOCK timeout for vnode locks (used mainly by the pageout daemon) 298 */ 299 #define VLKTIMEOUT (hz / 20 + 1) 300 301 #ifdef _KERNEL 302 303 /* 304 * Convert between vnode types and inode formats (since POSIX.1 305 * defines mode word of stat structure in terms of inode formats). 306 */ 307 extern enum vtype iftovt_tab[]; 308 extern int vttoif_tab[]; 309 #define IFTOVT(mode) (iftovt_tab[((mode) & S_IFMT) >> 12]) 310 #define VTTOIF(indx) (vttoif_tab[(int)(indx)]) 311 #define MAKEIMODE(indx, mode) (int)(VTTOIF(indx) | (mode)) 312 313 /* 314 * Flags to various vnode functions. 315 */ 316 #define SKIPSYSTEM 0x0001 /* vflush: skip vnodes marked VSYSTEM */ 317 #define FORCECLOSE 0x0002 /* vflush: force file closure */ 318 #define WRITECLOSE 0x0004 /* vflush: only close writable files */ 319 #define DOCLOSE 0x0008 /* vclean: close active files */ 320 #define V_SAVE 0x0001 /* vinvalbuf: sync file first */ 321 #define REVOKEALL 0x0001 /* vop_revoke: revoke all aliases */ 322 323 #ifdef DIAGNOSTIC 324 #define VATTR_NULL(vap) vattr_null(vap) 325 #else 326 #define VATTR_NULL(vap) (*(vap) = va_null) /* initialize a vattr */ 327 #endif /* DIAGNOSTIC */ 328 329 #define NULLVP ((struct vnode *)NULL) 330 331 #define VNODEOP_SET(f) \ 332 C_SYSINIT(f##init, SI_SUB_VFS, SI_ORDER_SECOND, vfs_add_vnodeops_sysinit, &f); \ 333 C_SYSUNINIT(f##uninit, SI_SUB_VFS, SI_ORDER_SECOND,vfs_rm_vnodeops_sysinit, &f); 334 335 /* 336 * Global vnode data. 337 */ 338 extern struct vnode *rootvnode; /* root (i.e. "/") vnode */ 339 extern struct namecache *rootncp; /* root (i.e. "/") namecache */ 340 extern int desiredvnodes; /* number of vnodes desired */ 341 extern time_t syncdelay; /* max time to delay syncing data */ 342 extern time_t filedelay; /* time to delay syncing files */ 343 extern time_t dirdelay; /* time to delay syncing directories */ 344 extern time_t metadelay; /* time to delay syncing metadata */ 345 extern struct vm_zone *namei_zone; 346 extern int prtactive; /* nonzero to call vprint() */ 347 extern struct vattr va_null; /* predefined null vattr structure */ 348 extern int vfs_ioopt; 349 extern int numvnodes; 350 extern int freevnodes; 351 extern int vfs_fastdev; /* fast specfs device access */ 352 353 /* 354 * Macro/function to check for client cache inconsistency w.r.t. leasing. 355 */ 356 #define LEASE_READ 0x1 /* Check lease for readers */ 357 #define LEASE_WRITE 0x2 /* Check lease for modifiers */ 358 359 360 extern void (*lease_updatetime) (int deltat); 361 362 #endif /* _KERNEL */ 363 364 /* 365 * Mods for extensibility. 366 */ 367 368 /* 369 * Flags for vdesc_flags: 370 */ 371 #define VDESC_MAX_VPS 8 372 /* Low order 8 flag bits are reserved for willrele flags for vp arguments. */ 373 #define VDESC_VP0_WILLRELE 0x00000001 374 #define VDESC_VP1_WILLRELE 0x00000002 375 #define VDESC_VP2_WILLRELE 0x00000004 376 #define VDESC_VP3_WILLRELE 0x00000008 377 #define VDESC_VP4_WILLRELE 0x00000010 378 #define VDESC_VP5_WILLRELE 0x00000020 379 #define VDESC_VP6_WILLRELE 0x00000040 380 #define VDESC_VP7_WILLRELE 0x00000080 381 #define VDESC_NOMAP_VPP 0x00000100 382 #define VDESC_VPP_WILLRELE 0x00000200 383 #define VDESC_VP0_WILLUNLOCK 0x00010000 384 #define VDESC_VP1_WILLUNLOCK 0x00020000 385 #define VDESC_VP2_WILLUNLOCK 0x00040000 386 #define VDESC_VP3_WILLUNLOCK 0x00080000 387 #define VDESC_VP4_WILLUNLOCK 0x00100000 388 #define VDESC_VP5_WILLUNLOCK 0x00200000 389 #define VDESC_VP6_WILLUNLOCK 0x00400000 390 #define VDESC_VP7_WILLUNLOCK 0x00800000 391 392 /* 393 * VDESC_NO_OFFSET is used to identify the end of the offset list 394 * and in places where no such field exists. 395 */ 396 #define VDESC_NO_OFFSET -1 397 398 /* 399 * This structure describes the vnode operation taking place. 400 */ 401 struct vnodeop_desc { 402 int vdesc_offset; /* offset in vector--first for speed */ 403 char *vdesc_name; /* a readable name for debugging */ 404 int vdesc_flags; /* VDESC_* flags */ 405 406 /* 407 * These ops are used by bypass routines to map and locate arguments. 408 * Creds and procs are not needed in bypass routines, but sometimes 409 * they are useful to (for example) transport layers. 410 * Nameidata is useful because it has a cred in it. 411 */ 412 int *vdesc_vp_offsets; /* list ended by VDESC_NO_OFFSET */ 413 int vdesc_vpp_offset; /* return vpp location */ 414 int vdesc_cred_offset; /* cred location, if any */ 415 int vdesc_proc_offset; /* proc location, if any */ 416 int vdesc_componentname_offset; /* if any */ 417 }; 418 419 #ifdef _KERNEL 420 /* 421 * A list of all the operation descs. 422 */ 423 extern struct vnodeop_desc *vnodeop_descs[]; 424 425 /* 426 * Interlock for scanning list of vnodes attached to a mountpoint 427 */ 428 extern struct lwkt_token mntvnode_token; 429 430 /* 431 * This macro is very helpful in defining those offsets in the vdesc struct. 432 * 433 * This is stolen from X11R4. I ignored all the fancy stuff for 434 * Crays, so if you decide to port this to such a serious machine, 435 * you might want to consult Intrinsic.h's XtOffset{,Of,To}. 436 */ 437 #define VOPARG_OFFSET(p_type,field) \ 438 ((int) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL))) 439 #define VOPARG_OFFSETOF(s_type,field) \ 440 VOPARG_OFFSET(s_type*,field) 441 #define VOPARG_OFFSETTO(S_TYPE,S_OFFSET,STRUCT_P) \ 442 ((S_TYPE)(((char*)(STRUCT_P))+(S_OFFSET))) 443 444 445 /* 446 * This structure is used to configure the new vnodeops vector. The entry 447 * descriptor describes a patricular VOP function while the operations 448 * vector descriptor recursively describes arrays of entry descriptors. 449 */ 450 struct vnodeopv_entry_desc { 451 struct vnodeop_desc *opve_op; 452 int (*opve_func)(struct vop_generic_args *ap); 453 }; 454 455 struct vnodeopv_desc { 456 struct vop_ops **opv_desc_vector; /* vect to allocate/fill*/ 457 struct vnodeopv_entry_desc *opv_desc_ops; /* null terminated list */ 458 }; 459 460 struct vnodeopv_node { 461 TAILQ_ENTRY(vnodeopv_node) entry; 462 struct vop_ops *ops; /* allocated vector */ 463 struct vnodeopv_entry_desc *descs; /* null terminated list */ 464 }; 465 466 #ifdef DEBUG_VFS_LOCKS 467 /* 468 * Macros to aid in tracing VFS locking problems. Not totally 469 * reliable since if the process sleeps between changing the lock 470 * state and checking it with the assert, some other process could 471 * change the state. They are good enough for debugging a single 472 * filesystem using a single-threaded test. I find that 'cvs co src' 473 * is a pretty good test. 474 */ 475 476 /* 477 * [dfr] Kludge until I get around to fixing all the vfs locking. 478 */ 479 #define IS_LOCKING_VFS(vp) ((vp)->v_tag == VT_UFS \ 480 || (vp)->v_tag == VT_MFS \ 481 || (vp)->v_tag == VT_NFS \ 482 || (vp)->v_tag == VT_LFS \ 483 || (vp)->v_tag == VT_ISOFS \ 484 || (vp)->v_tag == VT_MSDOSFS) 485 486 #define ASSERT_VOP_LOCKED(vp, str) assert_vop_locked(vp, str) 487 #define ASSERT_VOP_UNLOCKED(vp, str) assert_vop_unlocked(vp, str); 488 489 #define ASSERT_VOP_ELOCKED(vp, str) \ 490 do { \ 491 struct vnode *_vp = (vp); \ 492 \ 493 if (_vp && IS_LOCKING_VFS(_vp) && \ 494 VOP_ISLOCKED(_vp, curthread) != LK_EXCLUSIVE) \ 495 panic("%s: %p is not exclusive locked but should be", \ 496 str, _vp); \ 497 } while (0) 498 499 #define ASSERT_VOP_ELOCKED_OTHER(vp, str) \ 500 do { \ 501 struct vnode *_vp = (vp); \ 502 \ 503 if (_vp && IS_LOCKING_VFS(_vp) && \ 504 VOP_ISLOCKED(_vp, curthread) != LK_EXCLOTHER) \ 505 panic("%s: %p is not exclusive locked by another proc", \ 506 str, _vp); \ 507 } while (0) 508 509 #define ASSERT_VOP_SLOCKED(vp, str) \ 510 do { \ 511 struct vnode *_vp = (vp); \ 512 \ 513 if (_vp && IS_LOCKING_VFS(_vp) && \ 514 VOP_ISLOCKED(_vp, NULL) != LK_SHARED) \ 515 panic("%s: %p is not locked shared but should be", \ 516 str, _vp); \ 517 } while (0) 518 519 void assert_vop_locked(struct vnode *vp, const char *str); 520 void assert_vop_unlocked(struct vnode *vp, const char *str); 521 522 #else 523 524 #define ASSERT_VOP_LOCKED(vp, str) 525 #define ASSERT_VOP_UNLOCKED(vp, str) 526 527 #endif /* DEBUG_VFS_LOCKS */ 528 529 /* 530 * VOCALL calls an op given an ops vector. We break it out because BSD's 531 * vclean changes the ops vector and then wants to call ops with the old 532 * vector. 533 */ 534 535 typedef int (*vocall_func_t)(struct vop_generic_args *); 536 537 /* 538 * This call executes the vops vector for the offset stored in the ap's 539 * descriptor of the passed vops rather then the one related to the 540 * ap's vop_ops structure. It is used to chain VOPS calls on behalf of 541 * filesystems from a VFS's context ONLY (that is, from a VFS's own vops 542 * vector function). 543 */ 544 #define VOCALL(vops, ap) \ 545 (*(vocall_func_t *)((char *)(vops)+((ap)->a_desc->vdesc_offset)))(ap) 546 547 #define VDESC(OP) (& __CONCAT(OP,_desc)) 548 #define VOFFSET(OP) (VDESC(OP)->vdesc_offset) 549 550 /* 551 * VMIO support inline 552 */ 553 554 extern int vmiodirenable; 555 556 static __inline int 557 vn_canvmio(struct vnode *vp) 558 { 559 if (vp && (vp->v_type == VREG || (vmiodirenable && vp->v_type == VDIR))) 560 return(TRUE); 561 return(FALSE); 562 } 563 564 /* 565 * Public vnode manipulation functions. 566 */ 567 struct file; 568 struct mount; 569 struct nlookupdata; 570 struct ostat; 571 struct proc; 572 struct thread; 573 struct stat; 574 struct nstat; 575 struct ucred; 576 struct uio; 577 struct vattr; 578 struct vnode; 579 struct vop_bwrite_args; 580 581 extern int (*lease_check_hook) (struct vop_lease_args *); 582 583 void addaliasu (struct vnode *vp, udev_t nvp_udev); 584 int v_associate_rdev(struct vnode *vp, dev_t dev); 585 void v_release_rdev(struct vnode *vp); 586 int bdevvp (dev_t dev, struct vnode **vpp); 587 void cvtstat (struct stat *st, struct ostat *ost); 588 void cvtnstat (struct stat *sb, struct nstat *nsb); 589 struct vnode *allocvnode(int lktimeout, int lkflags); 590 struct vnode *allocvnode_placemarker(void); 591 void freevnode_placemarker(struct vnode *); 592 int getnewvnode (enum vtagtype tag, struct mount *mp, 593 struct vnode **vpp, int timo, int lkflags); 594 int getspecialvnode (enum vtagtype tag, struct mount *mp, 595 struct vop_ops **ops, struct vnode **vpp, int timo, 596 int lkflags); 597 int lease_check (struct vop_lease_args *ap); 598 int spec_vnoperate (struct vop_generic_args *); 599 int speedup_syncer (void); 600 void vattr_null (struct vattr *vap); 601 int vcount (struct vnode *vp); 602 int vfinddev (dev_t dev, enum vtype type, struct vnode **vpp); 603 void vfs_add_vnodeops_sysinit (const void *); 604 void vfs_rm_vnodeops_sysinit (const void *); 605 void vfs_add_vnodeops(struct mount *, struct vop_ops **, 606 struct vnodeopv_entry_desc *); 607 void vfs_rm_vnodeops(struct vop_ops **); 608 int vflush (struct mount *mp, int rootrefs, int flags); 609 int vmntvnodescan(struct mount *mp, int flags, 610 int (*fastfunc)(struct mount *mp, struct vnode *vp, void *data), 611 int (*slowfunc)(struct mount *mp, struct vnode *vp, void *data), 612 void *data); 613 void insmntque(struct vnode *vp, struct mount *mp); 614 615 void vclean (struct vnode *vp, int flags, struct thread *td); 616 void vgone (struct vnode *vp); 617 int vinvalbuf (struct vnode *vp, int save, 618 struct thread *td, int slpflag, int slptimeo); 619 int vtruncbuf (struct vnode *vp, struct thread *td, 620 off_t length, int blksize); 621 void vprint (char *label, struct vnode *vp); 622 int vrecycle (struct vnode *vp, struct thread *td); 623 int vn_close (struct vnode *vp, int flags, struct thread *td); 624 int vn_isdisk (struct vnode *vp, int *errp); 625 int vn_lock (struct vnode *vp, int flags, struct thread *td); 626 #ifdef DEBUG_LOCKS 627 int debug_vn_lock (struct vnode *vp, int flags, struct thread *td, 628 const char *filename, int line); 629 #define vn_lock(vp,flags,p) debug_vn_lock(vp,flags,p,__FILE__,__LINE__) 630 #endif 631 632 void vn_setspecops (struct file *fp); 633 int vn_fullpath (struct proc *p, struct vnode *vn, char **retbuf, char **freebuf); 634 int vn_open (struct nlookupdata *ndp, struct file *fp, int fmode, int cmode); 635 void vn_pollevent (struct vnode *vp, int events); 636 void vn_pollgone (struct vnode *vp); 637 int vn_pollrecord (struct vnode *vp, struct thread *td, int events); 638 int vn_rdwr (enum uio_rw rw, struct vnode *vp, caddr_t base, 639 int len, off_t offset, enum uio_seg segflg, int ioflg, 640 struct ucred *cred, int *aresid, struct thread *td); 641 int vn_rdwr_inchunks (enum uio_rw rw, struct vnode *vp, caddr_t base, 642 int len, off_t offset, enum uio_seg segflg, int ioflg, 643 struct ucred *cred, int *aresid, struct thread *td); 644 int vn_stat (struct vnode *vp, struct stat *sb, struct thread *td); 645 dev_t vn_todev (struct vnode *vp); 646 int vfs_object_create (struct vnode *vp, struct thread *td); 647 void vfs_timestamp (struct timespec *); 648 int vn_writechk (struct vnode *vp); 649 int vop_stdbwrite (struct vop_bwrite_args *ap); 650 int vop_stdislocked (struct vop_islocked_args *ap); 651 int vop_stdlock (struct vop_lock_args *ap); 652 int vop_stdrlock (struct vop_lock_args *ap); 653 int vop_stdunlock (struct vop_unlock_args *ap); 654 int vop_nopoll (struct vop_poll_args *ap); 655 int vop_stdpathconf (struct vop_pathconf_args *ap); 656 int vop_stdpoll (struct vop_poll_args *ap); 657 int vop_stdrevoke (struct vop_revoke_args *ap); 658 int vop_eopnotsupp (struct vop_generic_args *ap); 659 int vop_ebadf (struct vop_generic_args *ap); 660 int vop_einval (struct vop_generic_args *ap); 661 int vop_enotty (struct vop_generic_args *ap); 662 int vop_defaultop (struct vop_generic_args *ap); 663 int vop_null (struct vop_generic_args *ap); 664 int vop_panic (struct vop_generic_args *ap); 665 int vop_stdcreatevobject (struct vop_createvobject_args *ap); 666 int vop_stddestroyvobject (struct vop_destroyvobject_args *ap); 667 int vop_stdgetvobject (struct vop_getvobject_args *ap); 668 669 int vop_compat_nresolve(struct vop_nresolve_args *ap); 670 int vop_compat_nlookupdotdot(struct vop_nlookupdotdot_args *ap); 671 int vop_compat_ncreate(struct vop_ncreate_args *ap); 672 int vop_compat_nmkdir(struct vop_nmkdir_args *ap); 673 int vop_compat_nmknod(struct vop_nmknod_args *ap); 674 int vop_compat_nlink(struct vop_nlink_args *ap); 675 int vop_compat_nsymlink(struct vop_nsymlink_args *ap); 676 int vop_compat_nwhiteout(struct vop_nwhiteout_args *ap); 677 int vop_compat_nremove(struct vop_nremove_args *ap); 678 int vop_compat_nrmdir(struct vop_nrmdir_args *ap); 679 int vop_compat_nrename(struct vop_nrename_args *ap); 680 681 int vx_lock (struct vnode *vp); 682 void vx_unlock (struct vnode *vp); 683 int vx_get (struct vnode *vp); 684 int vx_get_nonblock (struct vnode *vp); 685 void vx_put (struct vnode *vp); 686 int vget (struct vnode *vp, int lockflag, struct thread *td); 687 void vput (struct vnode *vp); 688 void vhold (struct vnode *); 689 void vdrop (struct vnode *); 690 void vref (struct vnode *vp); 691 void vrele (struct vnode *vp); 692 void vsetflags (struct vnode *vp, int flags); 693 void vclrflags (struct vnode *vp, int flags); 694 695 void vfs_subr_init(void); 696 void vfs_mount_init(void); 697 void vfs_lock_init(void); 698 void vfs_sync_init(void); 699 700 void vn_syncer_add_to_worklist(struct vnode *, int); 701 void vnlru_proc_wait(void); 702 703 extern struct vop_ops *default_vnode_vops; 704 extern struct vop_ops *spec_vnode_vops; 705 extern struct vop_ops *dead_vnode_vops; 706 707 #endif /* _KERNEL */ 708 709 #endif /* !_SYS_VNODE_H_ */ 710