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