1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2013, Joyent, Inc. All rights reserved. 25 */ 26 27 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 28 /* All Rights Reserved */ 29 30 /* 31 * University Copyright- Copyright (c) 1982, 1986, 1988 32 * The Regents of the University of California 33 * All Rights Reserved 34 * 35 * University Acknowledgment- Portions of this document are derived from 36 * software developed by the University of California, Berkeley, and its 37 * contributors. 38 */ 39 40 #include <sys/types.h> 41 #include <sys/param.h> 42 #include <sys/t_lock.h> 43 #include <sys/errno.h> 44 #include <sys/cred.h> 45 #include <sys/user.h> 46 #include <sys/uio.h> 47 #include <sys/file.h> 48 #include <sys/pathname.h> 49 #include <sys/vfs.h> 50 #include <sys/vfs_opreg.h> 51 #include <sys/vnode.h> 52 #include <sys/rwstlock.h> 53 #include <sys/fem.h> 54 #include <sys/stat.h> 55 #include <sys/mode.h> 56 #include <sys/conf.h> 57 #include <sys/sysmacros.h> 58 #include <sys/cmn_err.h> 59 #include <sys/systm.h> 60 #include <sys/kmem.h> 61 #include <sys/debug.h> 62 #include <c2/audit.h> 63 #include <sys/acl.h> 64 #include <sys/nbmlock.h> 65 #include <sys/fcntl.h> 66 #include <fs/fs_subr.h> 67 #include <sys/taskq.h> 68 #include <fs/fs_reparse.h> 69 70 /* Determine if this vnode is a file that is read-only */ 71 #define ISROFILE(vp) \ 72 ((vp)->v_type != VCHR && (vp)->v_type != VBLK && \ 73 (vp)->v_type != VFIFO && vn_is_readonly(vp)) 74 75 /* Tunable via /etc/system; used only by admin/install */ 76 int nfs_global_client_only; 77 78 /* 79 * Array of vopstats_t for per-FS-type vopstats. This array has the same 80 * number of entries as and parallel to the vfssw table. (Arguably, it could 81 * be part of the vfssw table.) Once it's initialized, it's accessed using 82 * the same fstype index that is used to index into the vfssw table. 83 */ 84 vopstats_t **vopstats_fstype; 85 86 /* vopstats initialization template used for fast initialization via bcopy() */ 87 static vopstats_t *vs_templatep; 88 89 /* Kmem cache handle for vsk_anchor_t allocations */ 90 kmem_cache_t *vsk_anchor_cache; 91 92 /* file events cleanup routine */ 93 extern void free_fopdata(vnode_t *); 94 95 /* 96 * Root of AVL tree for the kstats associated with vopstats. Lock protects 97 * updates to vsktat_tree. 98 */ 99 avl_tree_t vskstat_tree; 100 kmutex_t vskstat_tree_lock; 101 102 /* Global variable which enables/disables the vopstats collection */ 103 int vopstats_enabled = 1; 104 105 /* 106 * forward declarations for internal vnode specific data (vsd) 107 */ 108 static void *vsd_realloc(void *, size_t, size_t); 109 110 /* 111 * forward declarations for reparse point functions 112 */ 113 static int fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr); 114 115 /* 116 * VSD -- VNODE SPECIFIC DATA 117 * The v_data pointer is typically used by a file system to store a 118 * pointer to the file system's private node (e.g. ufs inode, nfs rnode). 119 * However, there are times when additional project private data needs 120 * to be stored separately from the data (node) pointed to by v_data. 121 * This additional data could be stored by the file system itself or 122 * by a completely different kernel entity. VSD provides a way for 123 * callers to obtain a key and store a pointer to private data associated 124 * with a vnode. 125 * 126 * Callers are responsible for protecting the vsd by holding v_vsd_lock 127 * for calls to vsd_set() and vsd_get(). 128 */ 129 130 /* 131 * vsd_lock protects: 132 * vsd_nkeys - creation and deletion of vsd keys 133 * vsd_list - insertion and deletion of vsd_node in the vsd_list 134 * vsd_destructor - adding and removing destructors to the list 135 */ 136 static kmutex_t vsd_lock; 137 static uint_t vsd_nkeys; /* size of destructor array */ 138 /* list of vsd_node's */ 139 static list_t *vsd_list = NULL; 140 /* per-key destructor funcs */ 141 static void (**vsd_destructor)(void *); 142 143 /* 144 * The following is the common set of actions needed to update the 145 * vopstats structure from a vnode op. Both VOPSTATS_UPDATE() and 146 * VOPSTATS_UPDATE_IO() do almost the same thing, except for the 147 * recording of the bytes transferred. Since the code is similar 148 * but small, it is nearly a duplicate. Consequently any changes 149 * to one may need to be reflected in the other. 150 * Rundown of the variables: 151 * vp - Pointer to the vnode 152 * counter - Partial name structure member to update in vopstats for counts 153 * bytecounter - Partial name structure member to update in vopstats for bytes 154 * bytesval - Value to update in vopstats for bytes 155 * fstype - Index into vsanchor_fstype[], same as index into vfssw[] 156 * vsp - Pointer to vopstats structure (either in vfs or vsanchor_fstype[i]) 157 */ 158 159 #define VOPSTATS_UPDATE(vp, counter) { \ 160 vfs_t *vfsp = (vp)->v_vfsp; \ 161 if (vfsp && vfsp->vfs_implp && \ 162 (vfsp->vfs_flag & VFS_STATS) && (vp)->v_type != VBAD) { \ 163 vopstats_t *vsp = &vfsp->vfs_vopstats; \ 164 uint64_t *stataddr = &(vsp->n##counter.value.ui64); \ 165 extern void __dtrace_probe___fsinfo_##counter(vnode_t *, \ 166 size_t, uint64_t *); \ 167 __dtrace_probe___fsinfo_##counter(vp, 0, stataddr); \ 168 (*stataddr)++; \ 169 if ((vsp = vfsp->vfs_fstypevsp) != NULL) { \ 170 vsp->n##counter.value.ui64++; \ 171 } \ 172 } \ 173 } 174 175 #define VOPSTATS_UPDATE_IO(vp, counter, bytecounter, bytesval) { \ 176 vfs_t *vfsp = (vp)->v_vfsp; \ 177 if (vfsp && vfsp->vfs_implp && \ 178 (vfsp->vfs_flag & VFS_STATS) && (vp)->v_type != VBAD) { \ 179 vopstats_t *vsp = &vfsp->vfs_vopstats; \ 180 uint64_t *stataddr = &(vsp->n##counter.value.ui64); \ 181 extern void __dtrace_probe___fsinfo_##counter(vnode_t *, \ 182 size_t, uint64_t *); \ 183 __dtrace_probe___fsinfo_##counter(vp, bytesval, stataddr); \ 184 (*stataddr)++; \ 185 vsp->bytecounter.value.ui64 += bytesval; \ 186 if ((vsp = vfsp->vfs_fstypevsp) != NULL) { \ 187 vsp->n##counter.value.ui64++; \ 188 vsp->bytecounter.value.ui64 += bytesval; \ 189 } \ 190 } \ 191 } 192 193 /* 194 * If the filesystem does not support XIDs map credential 195 * If the vfsp is NULL, perhaps we should also map? 196 */ 197 #define VOPXID_MAP_CR(vp, cr) { \ 198 vfs_t *vfsp = (vp)->v_vfsp; \ 199 if (vfsp != NULL && (vfsp->vfs_flag & VFS_XID) == 0) \ 200 cr = crgetmapped(cr); \ 201 } 202 203 /* 204 * Convert stat(2) formats to vnode types and vice versa. (Knows about 205 * numerical order of S_IFMT and vnode types.) 206 */ 207 enum vtype iftovt_tab[] = { 208 VNON, VFIFO, VCHR, VNON, VDIR, VNON, VBLK, VNON, 209 VREG, VNON, VLNK, VNON, VSOCK, VNON, VNON, VNON 210 }; 211 212 ushort_t vttoif_tab[] = { 213 0, S_IFREG, S_IFDIR, S_IFBLK, S_IFCHR, S_IFLNK, S_IFIFO, 214 S_IFDOOR, 0, S_IFSOCK, S_IFPORT, 0 215 }; 216 217 /* 218 * The system vnode cache. 219 */ 220 221 kmem_cache_t *vn_cache; 222 223 224 /* 225 * Vnode operations vector. 226 */ 227 228 static const fs_operation_trans_def_t vn_ops_table[] = { 229 VOPNAME_OPEN, offsetof(struct vnodeops, vop_open), 230 fs_nosys, fs_nosys, 231 232 VOPNAME_CLOSE, offsetof(struct vnodeops, vop_close), 233 fs_nosys, fs_nosys, 234 235 VOPNAME_READ, offsetof(struct vnodeops, vop_read), 236 fs_nosys, fs_nosys, 237 238 VOPNAME_WRITE, offsetof(struct vnodeops, vop_write), 239 fs_nosys, fs_nosys, 240 241 VOPNAME_IOCTL, offsetof(struct vnodeops, vop_ioctl), 242 fs_nosys, fs_nosys, 243 244 VOPNAME_SETFL, offsetof(struct vnodeops, vop_setfl), 245 fs_setfl, fs_nosys, 246 247 VOPNAME_GETATTR, offsetof(struct vnodeops, vop_getattr), 248 fs_nosys, fs_nosys, 249 250 VOPNAME_SETATTR, offsetof(struct vnodeops, vop_setattr), 251 fs_nosys, fs_nosys, 252 253 VOPNAME_ACCESS, offsetof(struct vnodeops, vop_access), 254 fs_nosys, fs_nosys, 255 256 VOPNAME_LOOKUP, offsetof(struct vnodeops, vop_lookup), 257 fs_nosys, fs_nosys, 258 259 VOPNAME_CREATE, offsetof(struct vnodeops, vop_create), 260 fs_nosys, fs_nosys, 261 262 VOPNAME_REMOVE, offsetof(struct vnodeops, vop_remove), 263 fs_nosys, fs_nosys, 264 265 VOPNAME_LINK, offsetof(struct vnodeops, vop_link), 266 fs_nosys, fs_nosys, 267 268 VOPNAME_RENAME, offsetof(struct vnodeops, vop_rename), 269 fs_nosys, fs_nosys, 270 271 VOPNAME_MKDIR, offsetof(struct vnodeops, vop_mkdir), 272 fs_nosys, fs_nosys, 273 274 VOPNAME_RMDIR, offsetof(struct vnodeops, vop_rmdir), 275 fs_nosys, fs_nosys, 276 277 VOPNAME_READDIR, offsetof(struct vnodeops, vop_readdir), 278 fs_nosys, fs_nosys, 279 280 VOPNAME_SYMLINK, offsetof(struct vnodeops, vop_symlink), 281 fs_nosys, fs_nosys, 282 283 VOPNAME_READLINK, offsetof(struct vnodeops, vop_readlink), 284 fs_nosys, fs_nosys, 285 286 VOPNAME_FSYNC, offsetof(struct vnodeops, vop_fsync), 287 fs_nosys, fs_nosys, 288 289 VOPNAME_INACTIVE, offsetof(struct vnodeops, vop_inactive), 290 fs_nosys, fs_nosys, 291 292 VOPNAME_FID, offsetof(struct vnodeops, vop_fid), 293 fs_nosys, fs_nosys, 294 295 VOPNAME_RWLOCK, offsetof(struct vnodeops, vop_rwlock), 296 fs_rwlock, fs_rwlock, 297 298 VOPNAME_RWUNLOCK, offsetof(struct vnodeops, vop_rwunlock), 299 (fs_generic_func_p) fs_rwunlock, 300 (fs_generic_func_p) fs_rwunlock, /* no errors allowed */ 301 302 VOPNAME_SEEK, offsetof(struct vnodeops, vop_seek), 303 fs_nosys, fs_nosys, 304 305 VOPNAME_CMP, offsetof(struct vnodeops, vop_cmp), 306 fs_cmp, fs_cmp, /* no errors allowed */ 307 308 VOPNAME_FRLOCK, offsetof(struct vnodeops, vop_frlock), 309 fs_frlock, fs_nosys, 310 311 VOPNAME_SPACE, offsetof(struct vnodeops, vop_space), 312 fs_nosys, fs_nosys, 313 314 VOPNAME_REALVP, offsetof(struct vnodeops, vop_realvp), 315 fs_nosys, fs_nosys, 316 317 VOPNAME_GETPAGE, offsetof(struct vnodeops, vop_getpage), 318 fs_nosys, fs_nosys, 319 320 VOPNAME_PUTPAGE, offsetof(struct vnodeops, vop_putpage), 321 fs_nosys, fs_nosys, 322 323 VOPNAME_MAP, offsetof(struct vnodeops, vop_map), 324 (fs_generic_func_p) fs_nosys_map, 325 (fs_generic_func_p) fs_nosys_map, 326 327 VOPNAME_ADDMAP, offsetof(struct vnodeops, vop_addmap), 328 (fs_generic_func_p) fs_nosys_addmap, 329 (fs_generic_func_p) fs_nosys_addmap, 330 331 VOPNAME_DELMAP, offsetof(struct vnodeops, vop_delmap), 332 fs_nosys, fs_nosys, 333 334 VOPNAME_POLL, offsetof(struct vnodeops, vop_poll), 335 (fs_generic_func_p) fs_poll, (fs_generic_func_p) fs_nosys_poll, 336 337 VOPNAME_DUMP, offsetof(struct vnodeops, vop_dump), 338 fs_nosys, fs_nosys, 339 340 VOPNAME_PATHCONF, offsetof(struct vnodeops, vop_pathconf), 341 fs_pathconf, fs_nosys, 342 343 VOPNAME_PAGEIO, offsetof(struct vnodeops, vop_pageio), 344 fs_nosys, fs_nosys, 345 346 VOPNAME_DUMPCTL, offsetof(struct vnodeops, vop_dumpctl), 347 fs_nosys, fs_nosys, 348 349 VOPNAME_DISPOSE, offsetof(struct vnodeops, vop_dispose), 350 (fs_generic_func_p) fs_dispose, 351 (fs_generic_func_p) fs_nodispose, 352 353 VOPNAME_SETSECATTR, offsetof(struct vnodeops, vop_setsecattr), 354 fs_nosys, fs_nosys, 355 356 VOPNAME_GETSECATTR, offsetof(struct vnodeops, vop_getsecattr), 357 fs_fab_acl, fs_nosys, 358 359 VOPNAME_SHRLOCK, offsetof(struct vnodeops, vop_shrlock), 360 fs_shrlock, fs_nosys, 361 362 VOPNAME_VNEVENT, offsetof(struct vnodeops, vop_vnevent), 363 (fs_generic_func_p) fs_vnevent_nosupport, 364 (fs_generic_func_p) fs_vnevent_nosupport, 365 366 VOPNAME_REQZCBUF, offsetof(struct vnodeops, vop_reqzcbuf), 367 fs_nosys, fs_nosys, 368 369 VOPNAME_RETZCBUF, offsetof(struct vnodeops, vop_retzcbuf), 370 fs_nosys, fs_nosys, 371 372 NULL, 0, NULL, NULL 373 }; 374 375 /* Extensible attribute (xva) routines. */ 376 377 /* 378 * Zero out the structure, set the size of the requested/returned bitmaps, 379 * set AT_XVATTR in the embedded vattr_t's va_mask, and set up the pointer 380 * to the returned attributes array. 381 */ 382 void 383 xva_init(xvattr_t *xvap) 384 { 385 bzero(xvap, sizeof (xvattr_t)); 386 xvap->xva_mapsize = XVA_MAPSIZE; 387 xvap->xva_magic = XVA_MAGIC; 388 xvap->xva_vattr.va_mask = AT_XVATTR; 389 xvap->xva_rtnattrmapp = &(xvap->xva_rtnattrmap)[0]; 390 } 391 392 /* 393 * If AT_XVATTR is set, returns a pointer to the embedded xoptattr_t 394 * structure. Otherwise, returns NULL. 395 */ 396 xoptattr_t * 397 xva_getxoptattr(xvattr_t *xvap) 398 { 399 xoptattr_t *xoap = NULL; 400 if (xvap->xva_vattr.va_mask & AT_XVATTR) 401 xoap = &xvap->xva_xoptattrs; 402 return (xoap); 403 } 404 405 /* 406 * Used by the AVL routines to compare two vsk_anchor_t structures in the tree. 407 * We use the f_fsid reported by VFS_STATVFS() since we use that for the 408 * kstat name. 409 */ 410 static int 411 vska_compar(const void *n1, const void *n2) 412 { 413 int ret; 414 ulong_t p1 = ((vsk_anchor_t *)n1)->vsk_fsid; 415 ulong_t p2 = ((vsk_anchor_t *)n2)->vsk_fsid; 416 417 if (p1 < p2) { 418 ret = -1; 419 } else if (p1 > p2) { 420 ret = 1; 421 } else { 422 ret = 0; 423 } 424 425 return (ret); 426 } 427 428 /* 429 * Used to create a single template which will be bcopy()ed to a newly 430 * allocated vsanchor_combo_t structure in new_vsanchor(), below. 431 */ 432 static vopstats_t * 433 create_vopstats_template() 434 { 435 vopstats_t *vsp; 436 437 vsp = kmem_alloc(sizeof (vopstats_t), KM_SLEEP); 438 bzero(vsp, sizeof (*vsp)); /* Start fresh */ 439 440 /* VOP_OPEN */ 441 kstat_named_init(&vsp->nopen, "nopen", KSTAT_DATA_UINT64); 442 /* VOP_CLOSE */ 443 kstat_named_init(&vsp->nclose, "nclose", KSTAT_DATA_UINT64); 444 /* VOP_READ I/O */ 445 kstat_named_init(&vsp->nread, "nread", KSTAT_DATA_UINT64); 446 kstat_named_init(&vsp->read_bytes, "read_bytes", KSTAT_DATA_UINT64); 447 /* VOP_WRITE I/O */ 448 kstat_named_init(&vsp->nwrite, "nwrite", KSTAT_DATA_UINT64); 449 kstat_named_init(&vsp->write_bytes, "write_bytes", KSTAT_DATA_UINT64); 450 /* VOP_IOCTL */ 451 kstat_named_init(&vsp->nioctl, "nioctl", KSTAT_DATA_UINT64); 452 /* VOP_SETFL */ 453 kstat_named_init(&vsp->nsetfl, "nsetfl", KSTAT_DATA_UINT64); 454 /* VOP_GETATTR */ 455 kstat_named_init(&vsp->ngetattr, "ngetattr", KSTAT_DATA_UINT64); 456 /* VOP_SETATTR */ 457 kstat_named_init(&vsp->nsetattr, "nsetattr", KSTAT_DATA_UINT64); 458 /* VOP_ACCESS */ 459 kstat_named_init(&vsp->naccess, "naccess", KSTAT_DATA_UINT64); 460 /* VOP_LOOKUP */ 461 kstat_named_init(&vsp->nlookup, "nlookup", KSTAT_DATA_UINT64); 462 /* VOP_CREATE */ 463 kstat_named_init(&vsp->ncreate, "ncreate", KSTAT_DATA_UINT64); 464 /* VOP_REMOVE */ 465 kstat_named_init(&vsp->nremove, "nremove", KSTAT_DATA_UINT64); 466 /* VOP_LINK */ 467 kstat_named_init(&vsp->nlink, "nlink", KSTAT_DATA_UINT64); 468 /* VOP_RENAME */ 469 kstat_named_init(&vsp->nrename, "nrename", KSTAT_DATA_UINT64); 470 /* VOP_MKDIR */ 471 kstat_named_init(&vsp->nmkdir, "nmkdir", KSTAT_DATA_UINT64); 472 /* VOP_RMDIR */ 473 kstat_named_init(&vsp->nrmdir, "nrmdir", KSTAT_DATA_UINT64); 474 /* VOP_READDIR I/O */ 475 kstat_named_init(&vsp->nreaddir, "nreaddir", KSTAT_DATA_UINT64); 476 kstat_named_init(&vsp->readdir_bytes, "readdir_bytes", 477 KSTAT_DATA_UINT64); 478 /* VOP_SYMLINK */ 479 kstat_named_init(&vsp->nsymlink, "nsymlink", KSTAT_DATA_UINT64); 480 /* VOP_READLINK */ 481 kstat_named_init(&vsp->nreadlink, "nreadlink", KSTAT_DATA_UINT64); 482 /* VOP_FSYNC */ 483 kstat_named_init(&vsp->nfsync, "nfsync", KSTAT_DATA_UINT64); 484 /* VOP_INACTIVE */ 485 kstat_named_init(&vsp->ninactive, "ninactive", KSTAT_DATA_UINT64); 486 /* VOP_FID */ 487 kstat_named_init(&vsp->nfid, "nfid", KSTAT_DATA_UINT64); 488 /* VOP_RWLOCK */ 489 kstat_named_init(&vsp->nrwlock, "nrwlock", KSTAT_DATA_UINT64); 490 /* VOP_RWUNLOCK */ 491 kstat_named_init(&vsp->nrwunlock, "nrwunlock", KSTAT_DATA_UINT64); 492 /* VOP_SEEK */ 493 kstat_named_init(&vsp->nseek, "nseek", KSTAT_DATA_UINT64); 494 /* VOP_CMP */ 495 kstat_named_init(&vsp->ncmp, "ncmp", KSTAT_DATA_UINT64); 496 /* VOP_FRLOCK */ 497 kstat_named_init(&vsp->nfrlock, "nfrlock", KSTAT_DATA_UINT64); 498 /* VOP_SPACE */ 499 kstat_named_init(&vsp->nspace, "nspace", KSTAT_DATA_UINT64); 500 /* VOP_REALVP */ 501 kstat_named_init(&vsp->nrealvp, "nrealvp", KSTAT_DATA_UINT64); 502 /* VOP_GETPAGE */ 503 kstat_named_init(&vsp->ngetpage, "ngetpage", KSTAT_DATA_UINT64); 504 /* VOP_PUTPAGE */ 505 kstat_named_init(&vsp->nputpage, "nputpage", KSTAT_DATA_UINT64); 506 /* VOP_MAP */ 507 kstat_named_init(&vsp->nmap, "nmap", KSTAT_DATA_UINT64); 508 /* VOP_ADDMAP */ 509 kstat_named_init(&vsp->naddmap, "naddmap", KSTAT_DATA_UINT64); 510 /* VOP_DELMAP */ 511 kstat_named_init(&vsp->ndelmap, "ndelmap", KSTAT_DATA_UINT64); 512 /* VOP_POLL */ 513 kstat_named_init(&vsp->npoll, "npoll", KSTAT_DATA_UINT64); 514 /* VOP_DUMP */ 515 kstat_named_init(&vsp->ndump, "ndump", KSTAT_DATA_UINT64); 516 /* VOP_PATHCONF */ 517 kstat_named_init(&vsp->npathconf, "npathconf", KSTAT_DATA_UINT64); 518 /* VOP_PAGEIO */ 519 kstat_named_init(&vsp->npageio, "npageio", KSTAT_DATA_UINT64); 520 /* VOP_DUMPCTL */ 521 kstat_named_init(&vsp->ndumpctl, "ndumpctl", KSTAT_DATA_UINT64); 522 /* VOP_DISPOSE */ 523 kstat_named_init(&vsp->ndispose, "ndispose", KSTAT_DATA_UINT64); 524 /* VOP_SETSECATTR */ 525 kstat_named_init(&vsp->nsetsecattr, "nsetsecattr", KSTAT_DATA_UINT64); 526 /* VOP_GETSECATTR */ 527 kstat_named_init(&vsp->ngetsecattr, "ngetsecattr", KSTAT_DATA_UINT64); 528 /* VOP_SHRLOCK */ 529 kstat_named_init(&vsp->nshrlock, "nshrlock", KSTAT_DATA_UINT64); 530 /* VOP_VNEVENT */ 531 kstat_named_init(&vsp->nvnevent, "nvnevent", KSTAT_DATA_UINT64); 532 /* VOP_REQZCBUF */ 533 kstat_named_init(&vsp->nreqzcbuf, "nreqzcbuf", KSTAT_DATA_UINT64); 534 /* VOP_RETZCBUF */ 535 kstat_named_init(&vsp->nretzcbuf, "nretzcbuf", KSTAT_DATA_UINT64); 536 537 return (vsp); 538 } 539 540 /* 541 * Creates a kstat structure associated with a vopstats structure. 542 */ 543 kstat_t * 544 new_vskstat(char *ksname, vopstats_t *vsp) 545 { 546 kstat_t *ksp; 547 548 if (!vopstats_enabled) { 549 return (NULL); 550 } 551 552 ksp = kstat_create("unix", 0, ksname, "misc", KSTAT_TYPE_NAMED, 553 sizeof (vopstats_t)/sizeof (kstat_named_t), 554 KSTAT_FLAG_VIRTUAL|KSTAT_FLAG_WRITABLE); 555 if (ksp) { 556 ksp->ks_data = vsp; 557 kstat_install(ksp); 558 } 559 560 return (ksp); 561 } 562 563 /* 564 * Called from vfsinit() to initialize the support mechanisms for vopstats 565 */ 566 void 567 vopstats_startup() 568 { 569 if (!vopstats_enabled) 570 return; 571 572 /* 573 * Creates the AVL tree which holds per-vfs vopstat anchors. This 574 * is necessary since we need to check if a kstat exists before we 575 * attempt to create it. Also, initialize its lock. 576 */ 577 avl_create(&vskstat_tree, vska_compar, sizeof (vsk_anchor_t), 578 offsetof(vsk_anchor_t, vsk_node)); 579 mutex_init(&vskstat_tree_lock, NULL, MUTEX_DEFAULT, NULL); 580 581 vsk_anchor_cache = kmem_cache_create("vsk_anchor_cache", 582 sizeof (vsk_anchor_t), sizeof (uintptr_t), NULL, NULL, NULL, 583 NULL, NULL, 0); 584 585 /* 586 * Set up the array of pointers for the vopstats-by-FS-type. 587 * The entries will be allocated/initialized as each file system 588 * goes through modload/mod_installfs. 589 */ 590 vopstats_fstype = (vopstats_t **)kmem_zalloc( 591 (sizeof (vopstats_t *) * nfstype), KM_SLEEP); 592 593 /* Set up the global vopstats initialization template */ 594 vs_templatep = create_vopstats_template(); 595 } 596 597 /* 598 * We need to have the all of the counters zeroed. 599 * The initialization of the vopstats_t includes on the order of 600 * 50 calls to kstat_named_init(). Rather that do that on every call, 601 * we do it once in a template (vs_templatep) then bcopy it over. 602 */ 603 void 604 initialize_vopstats(vopstats_t *vsp) 605 { 606 if (vsp == NULL) 607 return; 608 609 bcopy(vs_templatep, vsp, sizeof (vopstats_t)); 610 } 611 612 /* 613 * If possible, determine which vopstats by fstype to use and 614 * return a pointer to the caller. 615 */ 616 vopstats_t * 617 get_fstype_vopstats(vfs_t *vfsp, struct vfssw *vswp) 618 { 619 int fstype = 0; /* Index into vfssw[] */ 620 vopstats_t *vsp = NULL; 621 622 if (vfsp == NULL || (vfsp->vfs_flag & VFS_STATS) == 0 || 623 !vopstats_enabled) 624 return (NULL); 625 /* 626 * Set up the fstype. We go to so much trouble because all versions 627 * of NFS use the same fstype in their vfs even though they have 628 * distinct entries in the vfssw[] table. 629 * NOTE: A special vfs (e.g., EIO_vfs) may not have an entry. 630 */ 631 if (vswp) { 632 fstype = vswp - vfssw; /* Gets us the index */ 633 } else { 634 fstype = vfsp->vfs_fstype; 635 } 636 637 /* 638 * Point to the per-fstype vopstats. The only valid values are 639 * non-zero positive values less than the number of vfssw[] table 640 * entries. 641 */ 642 if (fstype > 0 && fstype < nfstype) { 643 vsp = vopstats_fstype[fstype]; 644 } 645 646 return (vsp); 647 } 648 649 /* 650 * Generate a kstat name, create the kstat structure, and allocate a 651 * vsk_anchor_t to hold it together. Return the pointer to the vsk_anchor_t 652 * to the caller. This must only be called from a mount. 653 */ 654 vsk_anchor_t * 655 get_vskstat_anchor(vfs_t *vfsp) 656 { 657 char kstatstr[KSTAT_STRLEN]; /* kstat name for vopstats */ 658 statvfs64_t statvfsbuf; /* Needed to find f_fsid */ 659 vsk_anchor_t *vskp = NULL; /* vfs <--> kstat anchor */ 660 kstat_t *ksp; /* Ptr to new kstat */ 661 avl_index_t where; /* Location in the AVL tree */ 662 663 if (vfsp == NULL || vfsp->vfs_implp == NULL || 664 (vfsp->vfs_flag & VFS_STATS) == 0 || !vopstats_enabled) 665 return (NULL); 666 667 /* Need to get the fsid to build a kstat name */ 668 if (VFS_STATVFS(vfsp, &statvfsbuf) == 0) { 669 /* Create a name for our kstats based on fsid */ 670 (void) snprintf(kstatstr, KSTAT_STRLEN, "%s%lx", 671 VOPSTATS_STR, statvfsbuf.f_fsid); 672 673 /* Allocate and initialize the vsk_anchor_t */ 674 vskp = kmem_cache_alloc(vsk_anchor_cache, KM_SLEEP); 675 bzero(vskp, sizeof (*vskp)); 676 vskp->vsk_fsid = statvfsbuf.f_fsid; 677 678 mutex_enter(&vskstat_tree_lock); 679 if (avl_find(&vskstat_tree, vskp, &where) == NULL) { 680 avl_insert(&vskstat_tree, vskp, where); 681 mutex_exit(&vskstat_tree_lock); 682 683 /* 684 * Now that we've got the anchor in the AVL 685 * tree, we can create the kstat. 686 */ 687 ksp = new_vskstat(kstatstr, &vfsp->vfs_vopstats); 688 if (ksp) { 689 vskp->vsk_ksp = ksp; 690 } 691 } else { 692 /* Oops, found one! Release memory and lock. */ 693 mutex_exit(&vskstat_tree_lock); 694 kmem_cache_free(vsk_anchor_cache, vskp); 695 vskp = NULL; 696 } 697 } 698 return (vskp); 699 } 700 701 /* 702 * We're in the process of tearing down the vfs and need to cleanup 703 * the data structures associated with the vopstats. Must only be called 704 * from dounmount(). 705 */ 706 void 707 teardown_vopstats(vfs_t *vfsp) 708 { 709 vsk_anchor_t *vskap; 710 avl_index_t where; 711 712 if (vfsp == NULL || vfsp->vfs_implp == NULL || 713 (vfsp->vfs_flag & VFS_STATS) == 0 || !vopstats_enabled) 714 return; 715 716 /* This is a safe check since VFS_STATS must be set (see above) */ 717 if ((vskap = vfsp->vfs_vskap) == NULL) 718 return; 719 720 /* Whack the pointer right away */ 721 vfsp->vfs_vskap = NULL; 722 723 /* Lock the tree, remove the node, and delete the kstat */ 724 mutex_enter(&vskstat_tree_lock); 725 if (avl_find(&vskstat_tree, vskap, &where)) { 726 avl_remove(&vskstat_tree, vskap); 727 } 728 729 if (vskap->vsk_ksp) { 730 kstat_delete(vskap->vsk_ksp); 731 } 732 mutex_exit(&vskstat_tree_lock); 733 734 kmem_cache_free(vsk_anchor_cache, vskap); 735 } 736 737 /* 738 * Read or write a vnode. Called from kernel code. 739 */ 740 int 741 vn_rdwr( 742 enum uio_rw rw, 743 struct vnode *vp, 744 caddr_t base, 745 ssize_t len, 746 offset_t offset, 747 enum uio_seg seg, 748 int ioflag, 749 rlim64_t ulimit, /* meaningful only if rw is UIO_WRITE */ 750 cred_t *cr, 751 ssize_t *residp) 752 { 753 struct uio uio; 754 struct iovec iov; 755 int error; 756 int in_crit = 0; 757 758 if (rw == UIO_WRITE && ISROFILE(vp)) 759 return (EROFS); 760 761 if (len < 0) 762 return (EIO); 763 764 VOPXID_MAP_CR(vp, cr); 765 766 iov.iov_base = base; 767 iov.iov_len = len; 768 uio.uio_iov = &iov; 769 uio.uio_iovcnt = 1; 770 uio.uio_loffset = offset; 771 uio.uio_segflg = (short)seg; 772 uio.uio_resid = len; 773 uio.uio_llimit = ulimit; 774 775 /* 776 * We have to enter the critical region before calling VOP_RWLOCK 777 * to avoid a deadlock with ufs. 778 */ 779 if (nbl_need_check(vp)) { 780 int svmand; 781 782 nbl_start_crit(vp, RW_READER); 783 in_crit = 1; 784 error = nbl_svmand(vp, cr, &svmand); 785 if (error != 0) 786 goto done; 787 if (nbl_conflict(vp, rw == UIO_WRITE ? NBL_WRITE : NBL_READ, 788 uio.uio_offset, uio.uio_resid, svmand, NULL)) { 789 error = EACCES; 790 goto done; 791 } 792 } 793 794 (void) VOP_RWLOCK(vp, 795 rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL); 796 if (rw == UIO_WRITE) { 797 uio.uio_fmode = FWRITE; 798 uio.uio_extflg = UIO_COPY_DEFAULT; 799 error = VOP_WRITE(vp, &uio, ioflag, cr, NULL); 800 } else { 801 uio.uio_fmode = FREAD; 802 uio.uio_extflg = UIO_COPY_CACHED; 803 error = VOP_READ(vp, &uio, ioflag, cr, NULL); 804 } 805 VOP_RWUNLOCK(vp, 806 rw == UIO_WRITE ? V_WRITELOCK_TRUE : V_WRITELOCK_FALSE, NULL); 807 if (residp) 808 *residp = uio.uio_resid; 809 else if (uio.uio_resid) 810 error = EIO; 811 812 done: 813 if (in_crit) 814 nbl_end_crit(vp); 815 return (error); 816 } 817 818 /* 819 * Release a vnode. Call VOP_INACTIVE on last reference or 820 * decrement reference count. 821 * 822 * To avoid race conditions, the v_count is left at 1 for 823 * the call to VOP_INACTIVE. This prevents another thread 824 * from reclaiming and releasing the vnode *before* the 825 * VOP_INACTIVE routine has a chance to destroy the vnode. 826 * We can't have more than 1 thread calling VOP_INACTIVE 827 * on a vnode. 828 */ 829 void 830 vn_rele(vnode_t *vp) 831 { 832 VERIFY(vp->v_count > 0); 833 mutex_enter(&vp->v_lock); 834 if (vp->v_count == 1) { 835 mutex_exit(&vp->v_lock); 836 VOP_INACTIVE(vp, CRED(), NULL); 837 return; 838 } 839 vp->v_count--; 840 mutex_exit(&vp->v_lock); 841 } 842 843 /* 844 * Release a vnode referenced by the DNLC. Multiple DNLC references are treated 845 * as a single reference, so v_count is not decremented until the last DNLC hold 846 * is released. This makes it possible to distinguish vnodes that are referenced 847 * only by the DNLC. 848 */ 849 void 850 vn_rele_dnlc(vnode_t *vp) 851 { 852 VERIFY((vp->v_count > 0) && (vp->v_count_dnlc > 0)); 853 mutex_enter(&vp->v_lock); 854 if (--vp->v_count_dnlc == 0) { 855 if (vp->v_count == 1) { 856 mutex_exit(&vp->v_lock); 857 VOP_INACTIVE(vp, CRED(), NULL); 858 return; 859 } 860 vp->v_count--; 861 } 862 mutex_exit(&vp->v_lock); 863 } 864 865 /* 866 * Like vn_rele() except that it clears v_stream under v_lock. 867 * This is used by sockfs when it dismantels the association between 868 * the sockfs node and the vnode in the underlaying file system. 869 * v_lock has to be held to prevent a thread coming through the lookupname 870 * path from accessing a stream head that is going away. 871 */ 872 void 873 vn_rele_stream(vnode_t *vp) 874 { 875 VERIFY(vp->v_count > 0); 876 mutex_enter(&vp->v_lock); 877 vp->v_stream = NULL; 878 if (vp->v_count == 1) { 879 mutex_exit(&vp->v_lock); 880 VOP_INACTIVE(vp, CRED(), NULL); 881 return; 882 } 883 vp->v_count--; 884 mutex_exit(&vp->v_lock); 885 } 886 887 static void 888 vn_rele_inactive(vnode_t *vp) 889 { 890 VOP_INACTIVE(vp, CRED(), NULL); 891 } 892 893 /* 894 * Like vn_rele() except if we are going to call VOP_INACTIVE() then do it 895 * asynchronously using a taskq. This can avoid deadlocks caused by re-entering 896 * the file system as a result of releasing the vnode. Note, file systems 897 * already have to handle the race where the vnode is incremented before the 898 * inactive routine is called and does its locking. 899 * 900 * Warning: Excessive use of this routine can lead to performance problems. 901 * This is because taskqs throttle back allocation if too many are created. 902 */ 903 void 904 vn_rele_async(vnode_t *vp, taskq_t *taskq) 905 { 906 VERIFY(vp->v_count > 0); 907 mutex_enter(&vp->v_lock); 908 if (vp->v_count == 1) { 909 mutex_exit(&vp->v_lock); 910 VERIFY(taskq_dispatch(taskq, (task_func_t *)vn_rele_inactive, 911 vp, TQ_SLEEP) != NULL); 912 return; 913 } 914 vp->v_count--; 915 mutex_exit(&vp->v_lock); 916 } 917 918 int 919 vn_open( 920 char *pnamep, 921 enum uio_seg seg, 922 int filemode, 923 int createmode, 924 struct vnode **vpp, 925 enum create crwhy, 926 mode_t umask) 927 { 928 return (vn_openat(pnamep, seg, filemode, createmode, vpp, crwhy, 929 umask, NULL, -1)); 930 } 931 932 933 /* 934 * Open/create a vnode. 935 * This may be callable by the kernel, the only known use 936 * of user context being that the current user credentials 937 * are used for permissions. crwhy is defined iff filemode & FCREAT. 938 */ 939 int 940 vn_openat( 941 char *pnamep, 942 enum uio_seg seg, 943 int filemode, 944 int createmode, 945 struct vnode **vpp, 946 enum create crwhy, 947 mode_t umask, 948 struct vnode *startvp, 949 int fd) 950 { 951 struct vnode *vp; 952 int mode; 953 int accessflags; 954 int error; 955 int in_crit = 0; 956 int open_done = 0; 957 int shrlock_done = 0; 958 struct vattr vattr; 959 enum symfollow follow; 960 int estale_retry = 0; 961 struct shrlock shr; 962 struct shr_locowner shr_own; 963 964 mode = 0; 965 accessflags = 0; 966 if (filemode & FREAD) 967 mode |= VREAD; 968 if (filemode & (FWRITE|FTRUNC)) 969 mode |= VWRITE; 970 if (filemode & (FSEARCH|FEXEC|FXATTRDIROPEN)) 971 mode |= VEXEC; 972 973 /* symlink interpretation */ 974 if (filemode & FNOFOLLOW) 975 follow = NO_FOLLOW; 976 else 977 follow = FOLLOW; 978 979 if (filemode & FAPPEND) 980 accessflags |= V_APPEND; 981 982 top: 983 if (filemode & FCREAT) { 984 enum vcexcl excl; 985 986 /* 987 * Wish to create a file. 988 */ 989 vattr.va_type = VREG; 990 vattr.va_mode = createmode; 991 vattr.va_mask = AT_TYPE|AT_MODE; 992 if (filemode & FTRUNC) { 993 vattr.va_size = 0; 994 vattr.va_mask |= AT_SIZE; 995 } 996 if (filemode & FEXCL) 997 excl = EXCL; 998 else 999 excl = NONEXCL; 1000 1001 if (error = 1002 vn_createat(pnamep, seg, &vattr, excl, mode, &vp, crwhy, 1003 (filemode & ~(FTRUNC|FEXCL)), umask, startvp)) 1004 return (error); 1005 } else { 1006 /* 1007 * Wish to open a file. Just look it up. 1008 */ 1009 if (error = lookupnameat(pnamep, seg, follow, 1010 NULLVPP, &vp, startvp)) { 1011 if ((error == ESTALE) && 1012 fs_need_estale_retry(estale_retry++)) 1013 goto top; 1014 return (error); 1015 } 1016 1017 /* 1018 * Get the attributes to check whether file is large. 1019 * We do this only if the FOFFMAX flag is not set and 1020 * only for regular files. 1021 */ 1022 1023 if (!(filemode & FOFFMAX) && (vp->v_type == VREG)) { 1024 vattr.va_mask = AT_SIZE; 1025 if ((error = VOP_GETATTR(vp, &vattr, 0, 1026 CRED(), NULL))) { 1027 goto out; 1028 } 1029 if (vattr.va_size > (u_offset_t)MAXOFF32_T) { 1030 /* 1031 * Large File API - regular open fails 1032 * if FOFFMAX flag is set in file mode 1033 */ 1034 error = EOVERFLOW; 1035 goto out; 1036 } 1037 } 1038 /* 1039 * Can't write directories, active texts, or 1040 * read-only filesystems. Can't truncate files 1041 * on which mandatory locking is in effect. 1042 */ 1043 if (filemode & (FWRITE|FTRUNC)) { 1044 /* 1045 * Allow writable directory if VDIROPEN flag is set. 1046 */ 1047 if (vp->v_type == VDIR && !(vp->v_flag & VDIROPEN)) { 1048 error = EISDIR; 1049 goto out; 1050 } 1051 if (ISROFILE(vp)) { 1052 error = EROFS; 1053 goto out; 1054 } 1055 /* 1056 * Can't truncate files on which 1057 * sysv mandatory locking is in effect. 1058 */ 1059 if (filemode & FTRUNC) { 1060 vnode_t *rvp; 1061 1062 if (VOP_REALVP(vp, &rvp, NULL) != 0) 1063 rvp = vp; 1064 if (rvp->v_filocks != NULL) { 1065 vattr.va_mask = AT_MODE; 1066 if ((error = VOP_GETATTR(vp, 1067 &vattr, 0, CRED(), NULL)) == 0 && 1068 MANDLOCK(vp, vattr.va_mode)) 1069 error = EAGAIN; 1070 } 1071 } 1072 if (error) 1073 goto out; 1074 } 1075 /* 1076 * Check permissions. 1077 */ 1078 if (error = VOP_ACCESS(vp, mode, accessflags, CRED(), NULL)) 1079 goto out; 1080 /* 1081 * Require FSEARCH to return a directory. 1082 * Require FEXEC to return a regular file. 1083 */ 1084 if ((filemode & FSEARCH) && vp->v_type != VDIR) { 1085 error = ENOTDIR; 1086 goto out; 1087 } 1088 if ((filemode & FEXEC) && vp->v_type != VREG) { 1089 error = ENOEXEC; /* XXX: error code? */ 1090 goto out; 1091 } 1092 } 1093 1094 /* 1095 * Do remaining checks for FNOFOLLOW and FNOLINKS. 1096 */ 1097 if ((filemode & FNOFOLLOW) && vp->v_type == VLNK) { 1098 error = ELOOP; 1099 goto out; 1100 } 1101 if (filemode & FNOLINKS) { 1102 vattr.va_mask = AT_NLINK; 1103 if ((error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL))) { 1104 goto out; 1105 } 1106 if (vattr.va_nlink != 1) { 1107 error = EMLINK; 1108 goto out; 1109 } 1110 } 1111 1112 /* 1113 * Opening a socket corresponding to the AF_UNIX pathname 1114 * in the filesystem name space is not supported. 1115 * However, VSOCK nodes in namefs are supported in order 1116 * to make fattach work for sockets. 1117 * 1118 * XXX This uses VOP_REALVP to distinguish between 1119 * an unopened namefs node (where VOP_REALVP returns a 1120 * different VSOCK vnode) and a VSOCK created by vn_create 1121 * in some file system (where VOP_REALVP would never return 1122 * a different vnode). 1123 */ 1124 if (vp->v_type == VSOCK) { 1125 struct vnode *nvp; 1126 1127 error = VOP_REALVP(vp, &nvp, NULL); 1128 if (error != 0 || nvp == NULL || nvp == vp || 1129 nvp->v_type != VSOCK) { 1130 error = EOPNOTSUPP; 1131 goto out; 1132 } 1133 } 1134 1135 if ((vp->v_type == VREG) && nbl_need_check(vp)) { 1136 /* get share reservation */ 1137 shr.s_access = 0; 1138 if (filemode & FWRITE) 1139 shr.s_access |= F_WRACC; 1140 if (filemode & FREAD) 1141 shr.s_access |= F_RDACC; 1142 shr.s_deny = 0; 1143 shr.s_sysid = 0; 1144 shr.s_pid = ttoproc(curthread)->p_pid; 1145 shr_own.sl_pid = shr.s_pid; 1146 shr_own.sl_id = fd; 1147 shr.s_own_len = sizeof (shr_own); 1148 shr.s_owner = (caddr_t)&shr_own; 1149 error = VOP_SHRLOCK(vp, F_SHARE_NBMAND, &shr, filemode, CRED(), 1150 NULL); 1151 if (error) 1152 goto out; 1153 shrlock_done = 1; 1154 1155 /* nbmand conflict check if truncating file */ 1156 if ((filemode & FTRUNC) && !(filemode & FCREAT)) { 1157 nbl_start_crit(vp, RW_READER); 1158 in_crit = 1; 1159 1160 vattr.va_mask = AT_SIZE; 1161 if (error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)) 1162 goto out; 1163 if (nbl_conflict(vp, NBL_WRITE, 0, vattr.va_size, 0, 1164 NULL)) { 1165 error = EACCES; 1166 goto out; 1167 } 1168 } 1169 } 1170 1171 /* 1172 * Do opening protocol. 1173 */ 1174 error = VOP_OPEN(&vp, filemode, CRED(), NULL); 1175 if (error) 1176 goto out; 1177 open_done = 1; 1178 1179 /* 1180 * Truncate if required. 1181 */ 1182 if ((filemode & FTRUNC) && !(filemode & FCREAT)) { 1183 vattr.va_size = 0; 1184 vattr.va_mask = AT_SIZE; 1185 if ((error = VOP_SETATTR(vp, &vattr, 0, CRED(), NULL)) != 0) 1186 goto out; 1187 } 1188 out: 1189 ASSERT(vp->v_count > 0); 1190 1191 if (in_crit) { 1192 nbl_end_crit(vp); 1193 in_crit = 0; 1194 } 1195 if (error) { 1196 if (open_done) { 1197 (void) VOP_CLOSE(vp, filemode, 1, (offset_t)0, CRED(), 1198 NULL); 1199 open_done = 0; 1200 shrlock_done = 0; 1201 } 1202 if (shrlock_done) { 1203 (void) VOP_SHRLOCK(vp, F_UNSHARE, &shr, 0, CRED(), 1204 NULL); 1205 shrlock_done = 0; 1206 } 1207 1208 /* 1209 * The following clause was added to handle a problem 1210 * with NFS consistency. It is possible that a lookup 1211 * of the file to be opened succeeded, but the file 1212 * itself doesn't actually exist on the server. This 1213 * is chiefly due to the DNLC containing an entry for 1214 * the file which has been removed on the server. In 1215 * this case, we just start over. If there was some 1216 * other cause for the ESTALE error, then the lookup 1217 * of the file will fail and the error will be returned 1218 * above instead of looping around from here. 1219 */ 1220 VN_RELE(vp); 1221 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1222 goto top; 1223 } else 1224 *vpp = vp; 1225 return (error); 1226 } 1227 1228 /* 1229 * The following two accessor functions are for the NFSv4 server. Since there 1230 * is no VOP_OPEN_UP/DOWNGRADE we need a way for the NFS server to keep the 1231 * vnode open counts correct when a client "upgrades" an open or does an 1232 * open_downgrade. In NFS, an upgrade or downgrade can not only change the 1233 * open mode (add or subtract read or write), but also change the share/deny 1234 * modes. However, share reservations are not integrated with OPEN, yet, so 1235 * we need to handle each separately. These functions are cleaner than having 1236 * the NFS server manipulate the counts directly, however, nobody else should 1237 * use these functions. 1238 */ 1239 void 1240 vn_open_upgrade( 1241 vnode_t *vp, 1242 int filemode) 1243 { 1244 ASSERT(vp->v_type == VREG); 1245 1246 if (filemode & FREAD) 1247 atomic_inc_32(&vp->v_rdcnt); 1248 if (filemode & FWRITE) 1249 atomic_inc_32(&vp->v_wrcnt); 1250 1251 } 1252 1253 void 1254 vn_open_downgrade( 1255 vnode_t *vp, 1256 int filemode) 1257 { 1258 ASSERT(vp->v_type == VREG); 1259 1260 if (filemode & FREAD) { 1261 ASSERT(vp->v_rdcnt > 0); 1262 atomic_dec_32(&vp->v_rdcnt); 1263 } 1264 if (filemode & FWRITE) { 1265 ASSERT(vp->v_wrcnt > 0); 1266 atomic_dec_32(&vp->v_wrcnt); 1267 } 1268 1269 } 1270 1271 int 1272 vn_create( 1273 char *pnamep, 1274 enum uio_seg seg, 1275 struct vattr *vap, 1276 enum vcexcl excl, 1277 int mode, 1278 struct vnode **vpp, 1279 enum create why, 1280 int flag, 1281 mode_t umask) 1282 { 1283 return (vn_createat(pnamep, seg, vap, excl, mode, vpp, why, flag, 1284 umask, NULL)); 1285 } 1286 1287 /* 1288 * Create a vnode (makenode). 1289 */ 1290 int 1291 vn_createat( 1292 char *pnamep, 1293 enum uio_seg seg, 1294 struct vattr *vap, 1295 enum vcexcl excl, 1296 int mode, 1297 struct vnode **vpp, 1298 enum create why, 1299 int flag, 1300 mode_t umask, 1301 struct vnode *startvp) 1302 { 1303 struct vnode *dvp; /* ptr to parent dir vnode */ 1304 struct vnode *vp = NULL; 1305 struct pathname pn; 1306 int error; 1307 int in_crit = 0; 1308 struct vattr vattr; 1309 enum symfollow follow; 1310 int estale_retry = 0; 1311 uint32_t auditing = AU_AUDITING(); 1312 1313 ASSERT((vap->va_mask & (AT_TYPE|AT_MODE)) == (AT_TYPE|AT_MODE)); 1314 1315 /* symlink interpretation */ 1316 if ((flag & FNOFOLLOW) || excl == EXCL) 1317 follow = NO_FOLLOW; 1318 else 1319 follow = FOLLOW; 1320 flag &= ~(FNOFOLLOW|FNOLINKS); 1321 1322 top: 1323 /* 1324 * Lookup directory. 1325 * If new object is a file, call lower level to create it. 1326 * Note that it is up to the lower level to enforce exclusive 1327 * creation, if the file is already there. 1328 * This allows the lower level to do whatever 1329 * locking or protocol that is needed to prevent races. 1330 * If the new object is directory call lower level to make 1331 * the new directory, with "." and "..". 1332 */ 1333 if (error = pn_get(pnamep, seg, &pn)) 1334 return (error); 1335 if (auditing) 1336 audit_vncreate_start(); 1337 dvp = NULL; 1338 *vpp = NULL; 1339 /* 1340 * lookup will find the parent directory for the vnode. 1341 * When it is done the pn holds the name of the entry 1342 * in the directory. 1343 * If this is a non-exclusive create we also find the node itself. 1344 */ 1345 error = lookuppnat(&pn, NULL, follow, &dvp, 1346 (excl == EXCL) ? NULLVPP : vpp, startvp); 1347 if (error) { 1348 pn_free(&pn); 1349 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1350 goto top; 1351 if (why == CRMKDIR && error == EINVAL) 1352 error = EEXIST; /* SVID */ 1353 return (error); 1354 } 1355 1356 if (why != CRMKNOD) 1357 vap->va_mode &= ~VSVTX; 1358 1359 /* 1360 * If default ACLs are defined for the directory don't apply the 1361 * umask if umask is passed. 1362 */ 1363 1364 if (umask) { 1365 1366 vsecattr_t vsec; 1367 1368 vsec.vsa_aclcnt = 0; 1369 vsec.vsa_aclentp = NULL; 1370 vsec.vsa_dfaclcnt = 0; 1371 vsec.vsa_dfaclentp = NULL; 1372 vsec.vsa_mask = VSA_DFACLCNT; 1373 error = VOP_GETSECATTR(dvp, &vsec, 0, CRED(), NULL); 1374 /* 1375 * If error is ENOSYS then treat it as no error 1376 * Don't want to force all file systems to support 1377 * aclent_t style of ACL's. 1378 */ 1379 if (error == ENOSYS) 1380 error = 0; 1381 if (error) { 1382 if (*vpp != NULL) 1383 VN_RELE(*vpp); 1384 goto out; 1385 } else { 1386 /* 1387 * Apply the umask if no default ACLs. 1388 */ 1389 if (vsec.vsa_dfaclcnt == 0) 1390 vap->va_mode &= ~umask; 1391 1392 /* 1393 * VOP_GETSECATTR() may have allocated memory for 1394 * ACLs we didn't request, so double-check and 1395 * free it if necessary. 1396 */ 1397 if (vsec.vsa_aclcnt && vsec.vsa_aclentp != NULL) 1398 kmem_free((caddr_t)vsec.vsa_aclentp, 1399 vsec.vsa_aclcnt * sizeof (aclent_t)); 1400 if (vsec.vsa_dfaclcnt && vsec.vsa_dfaclentp != NULL) 1401 kmem_free((caddr_t)vsec.vsa_dfaclentp, 1402 vsec.vsa_dfaclcnt * sizeof (aclent_t)); 1403 } 1404 } 1405 1406 /* 1407 * In general we want to generate EROFS if the file system is 1408 * readonly. However, POSIX (IEEE Std. 1003.1) section 5.3.1 1409 * documents the open system call, and it says that O_CREAT has no 1410 * effect if the file already exists. Bug 1119649 states 1411 * that open(path, O_CREAT, ...) fails when attempting to open an 1412 * existing file on a read only file system. Thus, the first part 1413 * of the following if statement has 3 checks: 1414 * if the file exists && 1415 * it is being open with write access && 1416 * the file system is read only 1417 * then generate EROFS 1418 */ 1419 if ((*vpp != NULL && (mode & VWRITE) && ISROFILE(*vpp)) || 1420 (*vpp == NULL && dvp->v_vfsp->vfs_flag & VFS_RDONLY)) { 1421 if (*vpp) 1422 VN_RELE(*vpp); 1423 error = EROFS; 1424 } else if (excl == NONEXCL && *vpp != NULL) { 1425 vnode_t *rvp; 1426 1427 /* 1428 * File already exists. If a mandatory lock has been 1429 * applied, return error. 1430 */ 1431 vp = *vpp; 1432 if (VOP_REALVP(vp, &rvp, NULL) != 0) 1433 rvp = vp; 1434 if ((vap->va_mask & AT_SIZE) && nbl_need_check(vp)) { 1435 nbl_start_crit(vp, RW_READER); 1436 in_crit = 1; 1437 } 1438 if (rvp->v_filocks != NULL || rvp->v_shrlocks != NULL) { 1439 vattr.va_mask = AT_MODE|AT_SIZE; 1440 if (error = VOP_GETATTR(vp, &vattr, 0, CRED(), NULL)) { 1441 goto out; 1442 } 1443 if (MANDLOCK(vp, vattr.va_mode)) { 1444 error = EAGAIN; 1445 goto out; 1446 } 1447 /* 1448 * File cannot be truncated if non-blocking mandatory 1449 * locks are currently on the file. 1450 */ 1451 if ((vap->va_mask & AT_SIZE) && in_crit) { 1452 u_offset_t offset; 1453 ssize_t length; 1454 1455 offset = vap->va_size > vattr.va_size ? 1456 vattr.va_size : vap->va_size; 1457 length = vap->va_size > vattr.va_size ? 1458 vap->va_size - vattr.va_size : 1459 vattr.va_size - vap->va_size; 1460 if (nbl_conflict(vp, NBL_WRITE, offset, 1461 length, 0, NULL)) { 1462 error = EACCES; 1463 goto out; 1464 } 1465 } 1466 } 1467 1468 /* 1469 * If the file is the root of a VFS, we've crossed a 1470 * mount point and the "containing" directory that we 1471 * acquired above (dvp) is irrelevant because it's in 1472 * a different file system. We apply VOP_CREATE to the 1473 * target itself instead of to the containing directory 1474 * and supply a null path name to indicate (conventionally) 1475 * the node itself as the "component" of interest. 1476 * 1477 * The intercession of the file system is necessary to 1478 * ensure that the appropriate permission checks are 1479 * done. 1480 */ 1481 if (vp->v_flag & VROOT) { 1482 ASSERT(why != CRMKDIR); 1483 error = VOP_CREATE(vp, "", vap, excl, mode, vpp, 1484 CRED(), flag, NULL, NULL); 1485 /* 1486 * If the create succeeded, it will have created 1487 * a new reference to the vnode. Give up the 1488 * original reference. The assertion should not 1489 * get triggered because NBMAND locks only apply to 1490 * VREG files. And if in_crit is non-zero for some 1491 * reason, detect that here, rather than when we 1492 * deference a null vp. 1493 */ 1494 ASSERT(in_crit == 0); 1495 VN_RELE(vp); 1496 vp = NULL; 1497 goto out; 1498 } 1499 1500 /* 1501 * Large File API - non-large open (FOFFMAX flag not set) 1502 * of regular file fails if the file size exceeds MAXOFF32_T. 1503 */ 1504 if (why != CRMKDIR && 1505 !(flag & FOFFMAX) && 1506 (vp->v_type == VREG)) { 1507 vattr.va_mask = AT_SIZE; 1508 if ((error = VOP_GETATTR(vp, &vattr, 0, 1509 CRED(), NULL))) { 1510 goto out; 1511 } 1512 if ((vattr.va_size > (u_offset_t)MAXOFF32_T)) { 1513 error = EOVERFLOW; 1514 goto out; 1515 } 1516 } 1517 } 1518 1519 if (error == 0) { 1520 /* 1521 * Call mkdir() if specified, otherwise create(). 1522 */ 1523 int must_be_dir = pn_fixslash(&pn); /* trailing '/'? */ 1524 1525 if (why == CRMKDIR) 1526 /* 1527 * N.B., if vn_createat() ever requests 1528 * case-insensitive behavior then it will need 1529 * to be passed to VOP_MKDIR(). VOP_CREATE() 1530 * will already get it via "flag" 1531 */ 1532 error = VOP_MKDIR(dvp, pn.pn_path, vap, vpp, CRED(), 1533 NULL, 0, NULL); 1534 else if (!must_be_dir) 1535 error = VOP_CREATE(dvp, pn.pn_path, vap, 1536 excl, mode, vpp, CRED(), flag, NULL, NULL); 1537 else 1538 error = ENOTDIR; 1539 } 1540 1541 out: 1542 1543 if (auditing) 1544 audit_vncreate_finish(*vpp, error); 1545 if (in_crit) { 1546 nbl_end_crit(vp); 1547 in_crit = 0; 1548 } 1549 if (vp != NULL) { 1550 VN_RELE(vp); 1551 vp = NULL; 1552 } 1553 pn_free(&pn); 1554 VN_RELE(dvp); 1555 /* 1556 * The following clause was added to handle a problem 1557 * with NFS consistency. It is possible that a lookup 1558 * of the file to be created succeeded, but the file 1559 * itself doesn't actually exist on the server. This 1560 * is chiefly due to the DNLC containing an entry for 1561 * the file which has been removed on the server. In 1562 * this case, we just start over. If there was some 1563 * other cause for the ESTALE error, then the lookup 1564 * of the file will fail and the error will be returned 1565 * above instead of looping around from here. 1566 */ 1567 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1568 goto top; 1569 return (error); 1570 } 1571 1572 int 1573 vn_link(char *from, char *to, enum uio_seg seg) 1574 { 1575 return (vn_linkat(NULL, from, NO_FOLLOW, NULL, to, seg)); 1576 } 1577 1578 int 1579 vn_linkat(vnode_t *fstartvp, char *from, enum symfollow follow, 1580 vnode_t *tstartvp, char *to, enum uio_seg seg) 1581 { 1582 struct vnode *fvp; /* from vnode ptr */ 1583 struct vnode *tdvp; /* to directory vnode ptr */ 1584 struct pathname pn; 1585 int error; 1586 struct vattr vattr; 1587 dev_t fsid; 1588 int estale_retry = 0; 1589 uint32_t auditing = AU_AUDITING(); 1590 1591 top: 1592 fvp = tdvp = NULL; 1593 if (error = pn_get(to, seg, &pn)) 1594 return (error); 1595 if (auditing && fstartvp != NULL) 1596 audit_setfsat_path(1); 1597 if (error = lookupnameat(from, seg, follow, NULLVPP, &fvp, fstartvp)) 1598 goto out; 1599 if (auditing && tstartvp != NULL) 1600 audit_setfsat_path(3); 1601 if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &tdvp, NULLVPP, tstartvp)) 1602 goto out; 1603 /* 1604 * Make sure both source vnode and target directory vnode are 1605 * in the same vfs and that it is writeable. 1606 */ 1607 vattr.va_mask = AT_FSID; 1608 if (error = VOP_GETATTR(fvp, &vattr, 0, CRED(), NULL)) 1609 goto out; 1610 fsid = vattr.va_fsid; 1611 vattr.va_mask = AT_FSID; 1612 if (error = VOP_GETATTR(tdvp, &vattr, 0, CRED(), NULL)) 1613 goto out; 1614 if (fsid != vattr.va_fsid) { 1615 error = EXDEV; 1616 goto out; 1617 } 1618 if (tdvp->v_vfsp->vfs_flag & VFS_RDONLY) { 1619 error = EROFS; 1620 goto out; 1621 } 1622 /* 1623 * Do the link. 1624 */ 1625 (void) pn_fixslash(&pn); 1626 error = VOP_LINK(tdvp, fvp, pn.pn_path, CRED(), NULL, 0); 1627 out: 1628 pn_free(&pn); 1629 if (fvp) 1630 VN_RELE(fvp); 1631 if (tdvp) 1632 VN_RELE(tdvp); 1633 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1634 goto top; 1635 return (error); 1636 } 1637 1638 int 1639 vn_rename(char *from, char *to, enum uio_seg seg) 1640 { 1641 return (vn_renameat(NULL, from, NULL, to, seg)); 1642 } 1643 1644 int 1645 vn_renameat(vnode_t *fdvp, char *fname, vnode_t *tdvp, 1646 char *tname, enum uio_seg seg) 1647 { 1648 int error; 1649 struct vattr vattr; 1650 struct pathname fpn; /* from pathname */ 1651 struct pathname tpn; /* to pathname */ 1652 dev_t fsid; 1653 int in_crit_src, in_crit_targ; 1654 vnode_t *fromvp, *fvp; 1655 vnode_t *tovp, *targvp; 1656 int estale_retry = 0; 1657 uint32_t auditing = AU_AUDITING(); 1658 1659 top: 1660 fvp = fromvp = tovp = targvp = NULL; 1661 in_crit_src = in_crit_targ = 0; 1662 /* 1663 * Get to and from pathnames. 1664 */ 1665 if (error = pn_get(fname, seg, &fpn)) 1666 return (error); 1667 if (error = pn_get(tname, seg, &tpn)) { 1668 pn_free(&fpn); 1669 return (error); 1670 } 1671 1672 /* 1673 * First we need to resolve the correct directories 1674 * The passed in directories may only be a starting point, 1675 * but we need the real directories the file(s) live in. 1676 * For example the fname may be something like usr/lib/sparc 1677 * and we were passed in the / directory, but we need to 1678 * use the lib directory for the rename. 1679 */ 1680 1681 if (auditing && fdvp != NULL) 1682 audit_setfsat_path(1); 1683 /* 1684 * Lookup to and from directories. 1685 */ 1686 if (error = lookuppnat(&fpn, NULL, NO_FOLLOW, &fromvp, &fvp, fdvp)) { 1687 goto out; 1688 } 1689 1690 /* 1691 * Make sure there is an entry. 1692 */ 1693 if (fvp == NULL) { 1694 error = ENOENT; 1695 goto out; 1696 } 1697 1698 if (auditing && tdvp != NULL) 1699 audit_setfsat_path(3); 1700 if (error = lookuppnat(&tpn, NULL, NO_FOLLOW, &tovp, &targvp, tdvp)) { 1701 goto out; 1702 } 1703 1704 /* 1705 * Make sure both the from vnode directory and the to directory 1706 * are in the same vfs and the to directory is writable. 1707 * We check fsid's, not vfs pointers, so loopback fs works. 1708 */ 1709 if (fromvp != tovp) { 1710 vattr.va_mask = AT_FSID; 1711 if (error = VOP_GETATTR(fromvp, &vattr, 0, CRED(), NULL)) 1712 goto out; 1713 fsid = vattr.va_fsid; 1714 vattr.va_mask = AT_FSID; 1715 if (error = VOP_GETATTR(tovp, &vattr, 0, CRED(), NULL)) 1716 goto out; 1717 if (fsid != vattr.va_fsid) { 1718 error = EXDEV; 1719 goto out; 1720 } 1721 } 1722 1723 if (tovp->v_vfsp->vfs_flag & VFS_RDONLY) { 1724 error = EROFS; 1725 goto out; 1726 } 1727 1728 if (targvp && (fvp != targvp)) { 1729 nbl_start_crit(targvp, RW_READER); 1730 in_crit_targ = 1; 1731 if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) { 1732 error = EACCES; 1733 goto out; 1734 } 1735 } 1736 1737 if (nbl_need_check(fvp)) { 1738 nbl_start_crit(fvp, RW_READER); 1739 in_crit_src = 1; 1740 if (nbl_conflict(fvp, NBL_RENAME, 0, 0, 0, NULL)) { 1741 error = EACCES; 1742 goto out; 1743 } 1744 } 1745 1746 /* 1747 * Do the rename. 1748 */ 1749 (void) pn_fixslash(&tpn); 1750 error = VOP_RENAME(fromvp, fpn.pn_path, tovp, tpn.pn_path, CRED(), 1751 NULL, 0); 1752 1753 out: 1754 pn_free(&fpn); 1755 pn_free(&tpn); 1756 if (in_crit_src) 1757 nbl_end_crit(fvp); 1758 if (in_crit_targ) 1759 nbl_end_crit(targvp); 1760 if (fromvp) 1761 VN_RELE(fromvp); 1762 if (tovp) 1763 VN_RELE(tovp); 1764 if (targvp) 1765 VN_RELE(targvp); 1766 if (fvp) 1767 VN_RELE(fvp); 1768 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1769 goto top; 1770 return (error); 1771 } 1772 1773 /* 1774 * Remove a file or directory. 1775 */ 1776 int 1777 vn_remove(char *fnamep, enum uio_seg seg, enum rm dirflag) 1778 { 1779 return (vn_removeat(NULL, fnamep, seg, dirflag)); 1780 } 1781 1782 int 1783 vn_removeat(vnode_t *startvp, char *fnamep, enum uio_seg seg, enum rm dirflag) 1784 { 1785 struct vnode *vp; /* entry vnode */ 1786 struct vnode *dvp; /* ptr to parent dir vnode */ 1787 struct vnode *coveredvp; 1788 struct pathname pn; /* name of entry */ 1789 enum vtype vtype; 1790 int error; 1791 struct vfs *vfsp; 1792 struct vfs *dvfsp; /* ptr to parent dir vfs */ 1793 int in_crit = 0; 1794 int estale_retry = 0; 1795 1796 top: 1797 if (error = pn_get(fnamep, seg, &pn)) 1798 return (error); 1799 dvp = vp = NULL; 1800 if (error = lookuppnat(&pn, NULL, NO_FOLLOW, &dvp, &vp, startvp)) { 1801 pn_free(&pn); 1802 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1803 goto top; 1804 return (error); 1805 } 1806 1807 /* 1808 * Make sure there is an entry. 1809 */ 1810 if (vp == NULL) { 1811 error = ENOENT; 1812 goto out; 1813 } 1814 1815 vfsp = vp->v_vfsp; 1816 dvfsp = dvp->v_vfsp; 1817 1818 /* 1819 * If the named file is the root of a mounted filesystem, fail, 1820 * unless it's marked unlinkable. In that case, unmount the 1821 * filesystem and proceed to unlink the covered vnode. (If the 1822 * covered vnode is a directory, use rmdir instead of unlink, 1823 * to avoid file system corruption.) 1824 */ 1825 if (vp->v_flag & VROOT) { 1826 if ((vfsp->vfs_flag & VFS_UNLINKABLE) == 0) { 1827 error = EBUSY; 1828 goto out; 1829 } 1830 1831 /* 1832 * Namefs specific code starts here. 1833 */ 1834 1835 if (dirflag == RMDIRECTORY) { 1836 /* 1837 * User called rmdir(2) on a file that has 1838 * been namefs mounted on top of. Since 1839 * namefs doesn't allow directories to 1840 * be mounted on other files we know 1841 * vp is not of type VDIR so fail to operation. 1842 */ 1843 error = ENOTDIR; 1844 goto out; 1845 } 1846 1847 /* 1848 * If VROOT is still set after grabbing vp->v_lock, 1849 * noone has finished nm_unmount so far and coveredvp 1850 * is valid. 1851 * If we manage to grab vn_vfswlock(coveredvp) before releasing 1852 * vp->v_lock, any race window is eliminated. 1853 */ 1854 1855 mutex_enter(&vp->v_lock); 1856 if ((vp->v_flag & VROOT) == 0) { 1857 /* Someone beat us to the unmount */ 1858 mutex_exit(&vp->v_lock); 1859 error = EBUSY; 1860 goto out; 1861 } 1862 vfsp = vp->v_vfsp; 1863 coveredvp = vfsp->vfs_vnodecovered; 1864 ASSERT(coveredvp); 1865 /* 1866 * Note: Implementation of vn_vfswlock shows that ordering of 1867 * v_lock / vn_vfswlock is not an issue here. 1868 */ 1869 error = vn_vfswlock(coveredvp); 1870 mutex_exit(&vp->v_lock); 1871 1872 if (error) 1873 goto out; 1874 1875 VN_HOLD(coveredvp); 1876 VN_RELE(vp); 1877 error = dounmount(vfsp, 0, CRED()); 1878 1879 /* 1880 * Unmounted the namefs file system; now get 1881 * the object it was mounted over. 1882 */ 1883 vp = coveredvp; 1884 /* 1885 * If namefs was mounted over a directory, then 1886 * we want to use rmdir() instead of unlink(). 1887 */ 1888 if (vp->v_type == VDIR) 1889 dirflag = RMDIRECTORY; 1890 1891 if (error) 1892 goto out; 1893 } 1894 1895 /* 1896 * Make sure filesystem is writeable. 1897 * We check the parent directory's vfs in case this is an lofs vnode. 1898 */ 1899 if (dvfsp && dvfsp->vfs_flag & VFS_RDONLY) { 1900 error = EROFS; 1901 goto out; 1902 } 1903 1904 vtype = vp->v_type; 1905 1906 /* 1907 * If there is the possibility of an nbmand share reservation, make 1908 * sure it's okay to remove the file. Keep a reference to the 1909 * vnode, so that we can exit the nbl critical region after 1910 * calling VOP_REMOVE. 1911 * If there is no possibility of an nbmand share reservation, 1912 * release the vnode reference now. Filesystems like NFS may 1913 * behave differently if there is an extra reference, so get rid of 1914 * this one. Fortunately, we can't have nbmand mounts on NFS 1915 * filesystems. 1916 */ 1917 if (nbl_need_check(vp)) { 1918 nbl_start_crit(vp, RW_READER); 1919 in_crit = 1; 1920 if (nbl_conflict(vp, NBL_REMOVE, 0, 0, 0, NULL)) { 1921 error = EACCES; 1922 goto out; 1923 } 1924 } else { 1925 VN_RELE(vp); 1926 vp = NULL; 1927 } 1928 1929 if (dirflag == RMDIRECTORY) { 1930 /* 1931 * Caller is using rmdir(2), which can only be applied to 1932 * directories. 1933 */ 1934 if (vtype != VDIR) { 1935 error = ENOTDIR; 1936 } else { 1937 vnode_t *cwd; 1938 proc_t *pp = curproc; 1939 1940 mutex_enter(&pp->p_lock); 1941 cwd = PTOU(pp)->u_cdir; 1942 VN_HOLD(cwd); 1943 mutex_exit(&pp->p_lock); 1944 error = VOP_RMDIR(dvp, pn.pn_path, cwd, CRED(), 1945 NULL, 0); 1946 VN_RELE(cwd); 1947 } 1948 } else { 1949 /* 1950 * Unlink(2) can be applied to anything. 1951 */ 1952 error = VOP_REMOVE(dvp, pn.pn_path, CRED(), NULL, 0); 1953 } 1954 1955 out: 1956 pn_free(&pn); 1957 if (in_crit) { 1958 nbl_end_crit(vp); 1959 in_crit = 0; 1960 } 1961 if (vp != NULL) 1962 VN_RELE(vp); 1963 if (dvp != NULL) 1964 VN_RELE(dvp); 1965 if ((error == ESTALE) && fs_need_estale_retry(estale_retry++)) 1966 goto top; 1967 return (error); 1968 } 1969 1970 /* 1971 * Utility function to compare equality of vnodes. 1972 * Compare the underlying real vnodes, if there are underlying vnodes. 1973 * This is a more thorough comparison than the VN_CMP() macro provides. 1974 */ 1975 int 1976 vn_compare(vnode_t *vp1, vnode_t *vp2) 1977 { 1978 vnode_t *realvp; 1979 1980 if (vp1 != NULL && VOP_REALVP(vp1, &realvp, NULL) == 0) 1981 vp1 = realvp; 1982 if (vp2 != NULL && VOP_REALVP(vp2, &realvp, NULL) == 0) 1983 vp2 = realvp; 1984 return (VN_CMP(vp1, vp2)); 1985 } 1986 1987 /* 1988 * The number of locks to hash into. This value must be a power 1989 * of 2 minus 1 and should probably also be prime. 1990 */ 1991 #define NUM_BUCKETS 1023 1992 1993 struct vn_vfslocks_bucket { 1994 kmutex_t vb_lock; 1995 vn_vfslocks_entry_t *vb_list; 1996 char pad[64 - sizeof (kmutex_t) - sizeof (void *)]; 1997 }; 1998 1999 /* 2000 * Total number of buckets will be NUM_BUCKETS + 1 . 2001 */ 2002 2003 #pragma align 64(vn_vfslocks_buckets) 2004 static struct vn_vfslocks_bucket vn_vfslocks_buckets[NUM_BUCKETS + 1]; 2005 2006 #define VN_VFSLOCKS_SHIFT 9 2007 2008 #define VN_VFSLOCKS_HASH(vfsvpptr) \ 2009 ((((intptr_t)(vfsvpptr)) >> VN_VFSLOCKS_SHIFT) & NUM_BUCKETS) 2010 2011 /* 2012 * vn_vfslocks_getlock() uses an HASH scheme to generate 2013 * rwstlock using vfs/vnode pointer passed to it. 2014 * 2015 * vn_vfslocks_rele() releases a reference in the 2016 * HASH table which allows the entry allocated by 2017 * vn_vfslocks_getlock() to be freed at a later 2018 * stage when the refcount drops to zero. 2019 */ 2020 2021 vn_vfslocks_entry_t * 2022 vn_vfslocks_getlock(void *vfsvpptr) 2023 { 2024 struct vn_vfslocks_bucket *bp; 2025 vn_vfslocks_entry_t *vep; 2026 vn_vfslocks_entry_t *tvep; 2027 2028 ASSERT(vfsvpptr != NULL); 2029 bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vfsvpptr)]; 2030 2031 mutex_enter(&bp->vb_lock); 2032 for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) { 2033 if (vep->ve_vpvfs == vfsvpptr) { 2034 vep->ve_refcnt++; 2035 mutex_exit(&bp->vb_lock); 2036 return (vep); 2037 } 2038 } 2039 mutex_exit(&bp->vb_lock); 2040 vep = kmem_alloc(sizeof (*vep), KM_SLEEP); 2041 rwst_init(&vep->ve_lock, NULL, RW_DEFAULT, NULL); 2042 vep->ve_vpvfs = (char *)vfsvpptr; 2043 vep->ve_refcnt = 1; 2044 mutex_enter(&bp->vb_lock); 2045 for (tvep = bp->vb_list; tvep != NULL; tvep = tvep->ve_next) { 2046 if (tvep->ve_vpvfs == vfsvpptr) { 2047 tvep->ve_refcnt++; 2048 mutex_exit(&bp->vb_lock); 2049 2050 /* 2051 * There is already an entry in the hash 2052 * destroy what we just allocated. 2053 */ 2054 rwst_destroy(&vep->ve_lock); 2055 kmem_free(vep, sizeof (*vep)); 2056 return (tvep); 2057 } 2058 } 2059 vep->ve_next = bp->vb_list; 2060 bp->vb_list = vep; 2061 mutex_exit(&bp->vb_lock); 2062 return (vep); 2063 } 2064 2065 void 2066 vn_vfslocks_rele(vn_vfslocks_entry_t *vepent) 2067 { 2068 struct vn_vfslocks_bucket *bp; 2069 vn_vfslocks_entry_t *vep; 2070 vn_vfslocks_entry_t *pvep; 2071 2072 ASSERT(vepent != NULL); 2073 ASSERT(vepent->ve_vpvfs != NULL); 2074 2075 bp = &vn_vfslocks_buckets[VN_VFSLOCKS_HASH(vepent->ve_vpvfs)]; 2076 2077 mutex_enter(&bp->vb_lock); 2078 vepent->ve_refcnt--; 2079 2080 if ((int32_t)vepent->ve_refcnt < 0) 2081 cmn_err(CE_PANIC, "vn_vfslocks_rele: refcount negative"); 2082 2083 if (vepent->ve_refcnt == 0) { 2084 for (vep = bp->vb_list; vep != NULL; vep = vep->ve_next) { 2085 if (vep->ve_vpvfs == vepent->ve_vpvfs) { 2086 if (bp->vb_list == vep) 2087 bp->vb_list = vep->ve_next; 2088 else { 2089 /* LINTED */ 2090 pvep->ve_next = vep->ve_next; 2091 } 2092 mutex_exit(&bp->vb_lock); 2093 rwst_destroy(&vep->ve_lock); 2094 kmem_free(vep, sizeof (*vep)); 2095 return; 2096 } 2097 pvep = vep; 2098 } 2099 cmn_err(CE_PANIC, "vn_vfslocks_rele: vp/vfs not found"); 2100 } 2101 mutex_exit(&bp->vb_lock); 2102 } 2103 2104 /* 2105 * vn_vfswlock_wait is used to implement a lock which is logically a writers 2106 * lock protecting the v_vfsmountedhere field. 2107 * vn_vfswlock_wait has been modified to be similar to vn_vfswlock, 2108 * except that it blocks to acquire the lock VVFSLOCK. 2109 * 2110 * traverse() and routines re-implementing part of traverse (e.g. autofs) 2111 * need to hold this lock. mount(), vn_rename(), vn_remove() and so on 2112 * need the non-blocking version of the writers lock i.e. vn_vfswlock 2113 */ 2114 int 2115 vn_vfswlock_wait(vnode_t *vp) 2116 { 2117 int retval; 2118 vn_vfslocks_entry_t *vpvfsentry; 2119 ASSERT(vp != NULL); 2120 2121 vpvfsentry = vn_vfslocks_getlock(vp); 2122 retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_WRITER); 2123 2124 if (retval == EINTR) { 2125 vn_vfslocks_rele(vpvfsentry); 2126 return (EINTR); 2127 } 2128 return (retval); 2129 } 2130 2131 int 2132 vn_vfsrlock_wait(vnode_t *vp) 2133 { 2134 int retval; 2135 vn_vfslocks_entry_t *vpvfsentry; 2136 ASSERT(vp != NULL); 2137 2138 vpvfsentry = vn_vfslocks_getlock(vp); 2139 retval = rwst_enter_sig(&vpvfsentry->ve_lock, RW_READER); 2140 2141 if (retval == EINTR) { 2142 vn_vfslocks_rele(vpvfsentry); 2143 return (EINTR); 2144 } 2145 2146 return (retval); 2147 } 2148 2149 2150 /* 2151 * vn_vfswlock is used to implement a lock which is logically a writers lock 2152 * protecting the v_vfsmountedhere field. 2153 */ 2154 int 2155 vn_vfswlock(vnode_t *vp) 2156 { 2157 vn_vfslocks_entry_t *vpvfsentry; 2158 2159 /* 2160 * If vp is NULL then somebody is trying to lock the covered vnode 2161 * of /. (vfs_vnodecovered is NULL for /). This situation will 2162 * only happen when unmounting /. Since that operation will fail 2163 * anyway, return EBUSY here instead of in VFS_UNMOUNT. 2164 */ 2165 if (vp == NULL) 2166 return (EBUSY); 2167 2168 vpvfsentry = vn_vfslocks_getlock(vp); 2169 2170 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_WRITER)) 2171 return (0); 2172 2173 vn_vfslocks_rele(vpvfsentry); 2174 return (EBUSY); 2175 } 2176 2177 int 2178 vn_vfsrlock(vnode_t *vp) 2179 { 2180 vn_vfslocks_entry_t *vpvfsentry; 2181 2182 /* 2183 * If vp is NULL then somebody is trying to lock the covered vnode 2184 * of /. (vfs_vnodecovered is NULL for /). This situation will 2185 * only happen when unmounting /. Since that operation will fail 2186 * anyway, return EBUSY here instead of in VFS_UNMOUNT. 2187 */ 2188 if (vp == NULL) 2189 return (EBUSY); 2190 2191 vpvfsentry = vn_vfslocks_getlock(vp); 2192 2193 if (rwst_tryenter(&vpvfsentry->ve_lock, RW_READER)) 2194 return (0); 2195 2196 vn_vfslocks_rele(vpvfsentry); 2197 return (EBUSY); 2198 } 2199 2200 void 2201 vn_vfsunlock(vnode_t *vp) 2202 { 2203 vn_vfslocks_entry_t *vpvfsentry; 2204 2205 /* 2206 * ve_refcnt needs to be decremented twice. 2207 * 1. To release refernce after a call to vn_vfslocks_getlock() 2208 * 2. To release the reference from the locking routines like 2209 * vn_vfsrlock/vn_vfswlock etc,. 2210 */ 2211 vpvfsentry = vn_vfslocks_getlock(vp); 2212 vn_vfslocks_rele(vpvfsentry); 2213 2214 rwst_exit(&vpvfsentry->ve_lock); 2215 vn_vfslocks_rele(vpvfsentry); 2216 } 2217 2218 int 2219 vn_vfswlock_held(vnode_t *vp) 2220 { 2221 int held; 2222 vn_vfslocks_entry_t *vpvfsentry; 2223 2224 ASSERT(vp != NULL); 2225 2226 vpvfsentry = vn_vfslocks_getlock(vp); 2227 held = rwst_lock_held(&vpvfsentry->ve_lock, RW_WRITER); 2228 2229 vn_vfslocks_rele(vpvfsentry); 2230 return (held); 2231 } 2232 2233 2234 int 2235 vn_make_ops( 2236 const char *name, /* Name of file system */ 2237 const fs_operation_def_t *templ, /* Operation specification */ 2238 vnodeops_t **actual) /* Return the vnodeops */ 2239 { 2240 int unused_ops; 2241 int error; 2242 2243 *actual = (vnodeops_t *)kmem_alloc(sizeof (vnodeops_t), KM_SLEEP); 2244 2245 (*actual)->vnop_name = name; 2246 2247 error = fs_build_vector(*actual, &unused_ops, vn_ops_table, templ); 2248 if (error) { 2249 kmem_free(*actual, sizeof (vnodeops_t)); 2250 } 2251 2252 #if DEBUG 2253 if (unused_ops != 0) 2254 cmn_err(CE_WARN, "vn_make_ops: %s: %d operations supplied " 2255 "but not used", name, unused_ops); 2256 #endif 2257 2258 return (error); 2259 } 2260 2261 /* 2262 * Free the vnodeops created as a result of vn_make_ops() 2263 */ 2264 void 2265 vn_freevnodeops(vnodeops_t *vnops) 2266 { 2267 kmem_free(vnops, sizeof (vnodeops_t)); 2268 } 2269 2270 /* 2271 * Vnode cache. 2272 */ 2273 2274 /* ARGSUSED */ 2275 static int 2276 vn_cache_constructor(void *buf, void *cdrarg, int kmflags) 2277 { 2278 struct vnode *vp; 2279 2280 vp = buf; 2281 2282 mutex_init(&vp->v_lock, NULL, MUTEX_DEFAULT, NULL); 2283 mutex_init(&vp->v_vsd_lock, NULL, MUTEX_DEFAULT, NULL); 2284 cv_init(&vp->v_cv, NULL, CV_DEFAULT, NULL); 2285 rw_init(&vp->v_nbllock, NULL, RW_DEFAULT, NULL); 2286 vp->v_femhead = NULL; /* Must be done before vn_reinit() */ 2287 vp->v_path = NULL; 2288 vp->v_mpssdata = NULL; 2289 vp->v_vsd = NULL; 2290 vp->v_fopdata = NULL; 2291 2292 return (0); 2293 } 2294 2295 /* ARGSUSED */ 2296 static void 2297 vn_cache_destructor(void *buf, void *cdrarg) 2298 { 2299 struct vnode *vp; 2300 2301 vp = buf; 2302 2303 rw_destroy(&vp->v_nbllock); 2304 cv_destroy(&vp->v_cv); 2305 mutex_destroy(&vp->v_vsd_lock); 2306 mutex_destroy(&vp->v_lock); 2307 } 2308 2309 void 2310 vn_create_cache(void) 2311 { 2312 /* LINTED */ 2313 ASSERT((1 << VNODE_ALIGN_LOG2) == 2314 P2ROUNDUP(sizeof (struct vnode), VNODE_ALIGN)); 2315 vn_cache = kmem_cache_create("vn_cache", sizeof (struct vnode), 2316 VNODE_ALIGN, vn_cache_constructor, vn_cache_destructor, NULL, NULL, 2317 NULL, 0); 2318 } 2319 2320 void 2321 vn_destroy_cache(void) 2322 { 2323 kmem_cache_destroy(vn_cache); 2324 } 2325 2326 /* 2327 * Used by file systems when fs-specific nodes (e.g., ufs inodes) are 2328 * cached by the file system and vnodes remain associated. 2329 */ 2330 void 2331 vn_recycle(vnode_t *vp) 2332 { 2333 ASSERT(vp->v_pages == NULL); 2334 2335 /* 2336 * XXX - This really belongs in vn_reinit(), but we have some issues 2337 * with the counts. Best to have it here for clean initialization. 2338 */ 2339 vp->v_rdcnt = 0; 2340 vp->v_wrcnt = 0; 2341 vp->v_mmap_read = 0; 2342 vp->v_mmap_write = 0; 2343 2344 /* 2345 * If FEM was in use, make sure everything gets cleaned up 2346 * NOTE: vp->v_femhead is initialized to NULL in the vnode 2347 * constructor. 2348 */ 2349 if (vp->v_femhead) { 2350 /* XXX - There should be a free_femhead() that does all this */ 2351 ASSERT(vp->v_femhead->femh_list == NULL); 2352 mutex_destroy(&vp->v_femhead->femh_lock); 2353 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead))); 2354 vp->v_femhead = NULL; 2355 } 2356 if (vp->v_path) { 2357 kmem_free(vp->v_path, strlen(vp->v_path) + 1); 2358 vp->v_path = NULL; 2359 } 2360 2361 if (vp->v_fopdata != NULL) { 2362 free_fopdata(vp); 2363 } 2364 vp->v_mpssdata = NULL; 2365 vsd_free(vp); 2366 } 2367 2368 /* 2369 * Used to reset the vnode fields including those that are directly accessible 2370 * as well as those which require an accessor function. 2371 * 2372 * Does not initialize: 2373 * synchronization objects: v_lock, v_vsd_lock, v_nbllock, v_cv 2374 * v_data (since FS-nodes and vnodes point to each other and should 2375 * be updated simultaneously) 2376 * v_op (in case someone needs to make a VOP call on this object) 2377 */ 2378 void 2379 vn_reinit(vnode_t *vp) 2380 { 2381 vp->v_count = 1; 2382 vp->v_count_dnlc = 0; 2383 vp->v_vfsp = NULL; 2384 vp->v_stream = NULL; 2385 vp->v_vfsmountedhere = NULL; 2386 vp->v_flag = 0; 2387 vp->v_type = VNON; 2388 vp->v_rdev = NODEV; 2389 2390 vp->v_filocks = NULL; 2391 vp->v_shrlocks = NULL; 2392 vp->v_pages = NULL; 2393 2394 vp->v_locality = NULL; 2395 vp->v_xattrdir = NULL; 2396 2397 /* Handles v_femhead, v_path, and the r/w/map counts */ 2398 vn_recycle(vp); 2399 } 2400 2401 vnode_t * 2402 vn_alloc(int kmflag) 2403 { 2404 vnode_t *vp; 2405 2406 vp = kmem_cache_alloc(vn_cache, kmflag); 2407 2408 if (vp != NULL) { 2409 vp->v_femhead = NULL; /* Must be done before vn_reinit() */ 2410 vp->v_fopdata = NULL; 2411 vn_reinit(vp); 2412 } 2413 2414 return (vp); 2415 } 2416 2417 void 2418 vn_free(vnode_t *vp) 2419 { 2420 ASSERT(vp->v_shrlocks == NULL); 2421 ASSERT(vp->v_filocks == NULL); 2422 2423 /* 2424 * Some file systems call vn_free() with v_count of zero, 2425 * some with v_count of 1. In any case, the value should 2426 * never be anything else. 2427 */ 2428 ASSERT((vp->v_count == 0) || (vp->v_count == 1)); 2429 ASSERT(vp->v_count_dnlc == 0); 2430 if (vp->v_path != NULL) { 2431 kmem_free(vp->v_path, strlen(vp->v_path) + 1); 2432 vp->v_path = NULL; 2433 } 2434 2435 /* If FEM was in use, make sure everything gets cleaned up */ 2436 if (vp->v_femhead) { 2437 /* XXX - There should be a free_femhead() that does all this */ 2438 ASSERT(vp->v_femhead->femh_list == NULL); 2439 mutex_destroy(&vp->v_femhead->femh_lock); 2440 kmem_free(vp->v_femhead, sizeof (*(vp->v_femhead))); 2441 vp->v_femhead = NULL; 2442 } 2443 2444 if (vp->v_fopdata != NULL) { 2445 free_fopdata(vp); 2446 } 2447 vp->v_mpssdata = NULL; 2448 vsd_free(vp); 2449 kmem_cache_free(vn_cache, vp); 2450 } 2451 2452 /* 2453 * vnode status changes, should define better states than 1, 0. 2454 */ 2455 void 2456 vn_reclaim(vnode_t *vp) 2457 { 2458 vfs_t *vfsp = vp->v_vfsp; 2459 2460 if (vfsp == NULL || 2461 vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) { 2462 return; 2463 } 2464 (void) VFS_VNSTATE(vfsp, vp, VNTRANS_RECLAIMED); 2465 } 2466 2467 void 2468 vn_idle(vnode_t *vp) 2469 { 2470 vfs_t *vfsp = vp->v_vfsp; 2471 2472 if (vfsp == NULL || 2473 vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) { 2474 return; 2475 } 2476 (void) VFS_VNSTATE(vfsp, vp, VNTRANS_IDLED); 2477 } 2478 void 2479 vn_exists(vnode_t *vp) 2480 { 2481 vfs_t *vfsp = vp->v_vfsp; 2482 2483 if (vfsp == NULL || 2484 vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) { 2485 return; 2486 } 2487 (void) VFS_VNSTATE(vfsp, vp, VNTRANS_EXISTS); 2488 } 2489 2490 void 2491 vn_invalid(vnode_t *vp) 2492 { 2493 vfs_t *vfsp = vp->v_vfsp; 2494 2495 if (vfsp == NULL || 2496 vfsp->vfs_implp == NULL || vfsp->vfs_femhead == NULL) { 2497 return; 2498 } 2499 (void) VFS_VNSTATE(vfsp, vp, VNTRANS_DESTROYED); 2500 } 2501 2502 /* Vnode event notification */ 2503 2504 int 2505 vnevent_support(vnode_t *vp, caller_context_t *ct) 2506 { 2507 if (vp == NULL) 2508 return (EINVAL); 2509 2510 return (VOP_VNEVENT(vp, VE_SUPPORT, NULL, NULL, ct)); 2511 } 2512 2513 void 2514 vnevent_rename_src(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct) 2515 { 2516 if (vp == NULL || vp->v_femhead == NULL) { 2517 return; 2518 } 2519 (void) VOP_VNEVENT(vp, VE_RENAME_SRC, dvp, name, ct); 2520 } 2521 2522 void 2523 vnevent_rename_dest(vnode_t *vp, vnode_t *dvp, char *name, 2524 caller_context_t *ct) 2525 { 2526 if (vp == NULL || vp->v_femhead == NULL) { 2527 return; 2528 } 2529 (void) VOP_VNEVENT(vp, VE_RENAME_DEST, dvp, name, ct); 2530 } 2531 2532 void 2533 vnevent_rename_dest_dir(vnode_t *vp, caller_context_t *ct) 2534 { 2535 if (vp == NULL || vp->v_femhead == NULL) { 2536 return; 2537 } 2538 (void) VOP_VNEVENT(vp, VE_RENAME_DEST_DIR, NULL, NULL, ct); 2539 } 2540 2541 void 2542 vnevent_remove(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct) 2543 { 2544 if (vp == NULL || vp->v_femhead == NULL) { 2545 return; 2546 } 2547 (void) VOP_VNEVENT(vp, VE_REMOVE, dvp, name, ct); 2548 } 2549 2550 void 2551 vnevent_rmdir(vnode_t *vp, vnode_t *dvp, char *name, caller_context_t *ct) 2552 { 2553 if (vp == NULL || vp->v_femhead == NULL) { 2554 return; 2555 } 2556 (void) VOP_VNEVENT(vp, VE_RMDIR, dvp, name, ct); 2557 } 2558 2559 void 2560 vnevent_pre_rename_src(vnode_t *vp, vnode_t *dvp, char *name, 2561 caller_context_t *ct) 2562 { 2563 if (vp == NULL || vp->v_femhead == NULL) { 2564 return; 2565 } 2566 (void) VOP_VNEVENT(vp, VE_PRE_RENAME_SRC, dvp, name, ct); 2567 } 2568 2569 void 2570 vnevent_pre_rename_dest(vnode_t *vp, vnode_t *dvp, char *name, 2571 caller_context_t *ct) 2572 { 2573 if (vp == NULL || vp->v_femhead == NULL) { 2574 return; 2575 } 2576 (void) VOP_VNEVENT(vp, VE_PRE_RENAME_DEST, dvp, name, ct); 2577 } 2578 2579 void 2580 vnevent_pre_rename_dest_dir(vnode_t *vp, vnode_t *nvp, char *name, 2581 caller_context_t *ct) 2582 { 2583 if (vp == NULL || vp->v_femhead == NULL) { 2584 return; 2585 } 2586 (void) VOP_VNEVENT(vp, VE_PRE_RENAME_DEST_DIR, nvp, name, ct); 2587 } 2588 2589 void 2590 vnevent_create(vnode_t *vp, caller_context_t *ct) 2591 { 2592 if (vp == NULL || vp->v_femhead == NULL) { 2593 return; 2594 } 2595 (void) VOP_VNEVENT(vp, VE_CREATE, NULL, NULL, ct); 2596 } 2597 2598 void 2599 vnevent_link(vnode_t *vp, caller_context_t *ct) 2600 { 2601 if (vp == NULL || vp->v_femhead == NULL) { 2602 return; 2603 } 2604 (void) VOP_VNEVENT(vp, VE_LINK, NULL, NULL, ct); 2605 } 2606 2607 void 2608 vnevent_mountedover(vnode_t *vp, caller_context_t *ct) 2609 { 2610 if (vp == NULL || vp->v_femhead == NULL) { 2611 return; 2612 } 2613 (void) VOP_VNEVENT(vp, VE_MOUNTEDOVER, NULL, NULL, ct); 2614 } 2615 2616 void 2617 vnevent_truncate(vnode_t *vp, caller_context_t *ct) 2618 { 2619 if (vp == NULL || vp->v_femhead == NULL) { 2620 return; 2621 } 2622 (void) VOP_VNEVENT(vp, VE_TRUNCATE, NULL, NULL, ct); 2623 } 2624 2625 /* 2626 * Vnode accessors. 2627 */ 2628 2629 int 2630 vn_is_readonly(vnode_t *vp) 2631 { 2632 return (vp->v_vfsp->vfs_flag & VFS_RDONLY); 2633 } 2634 2635 int 2636 vn_has_flocks(vnode_t *vp) 2637 { 2638 return (vp->v_filocks != NULL); 2639 } 2640 2641 int 2642 vn_has_mandatory_locks(vnode_t *vp, int mode) 2643 { 2644 return ((vp->v_filocks != NULL) && (MANDLOCK(vp, mode))); 2645 } 2646 2647 int 2648 vn_has_cached_data(vnode_t *vp) 2649 { 2650 return (vp->v_pages != NULL); 2651 } 2652 2653 /* 2654 * Return 0 if the vnode in question shouldn't be permitted into a zone via 2655 * zone_enter(2). 2656 */ 2657 int 2658 vn_can_change_zones(vnode_t *vp) 2659 { 2660 struct vfssw *vswp; 2661 int allow = 1; 2662 vnode_t *rvp; 2663 2664 if (nfs_global_client_only != 0) 2665 return (1); 2666 2667 /* 2668 * We always want to look at the underlying vnode if there is one. 2669 */ 2670 if (VOP_REALVP(vp, &rvp, NULL) != 0) 2671 rvp = vp; 2672 /* 2673 * Some pseudo filesystems (including doorfs) don't actually register 2674 * their vfsops_t, so the following may return NULL; we happily let 2675 * such vnodes switch zones. 2676 */ 2677 vswp = vfs_getvfsswbyvfsops(vfs_getops(rvp->v_vfsp)); 2678 if (vswp != NULL) { 2679 if (vswp->vsw_flag & VSW_NOTZONESAFE) 2680 allow = 0; 2681 vfs_unrefvfssw(vswp); 2682 } 2683 return (allow); 2684 } 2685 2686 /* 2687 * Return nonzero if the vnode is a mount point, zero if not. 2688 */ 2689 int 2690 vn_ismntpt(vnode_t *vp) 2691 { 2692 return (vp->v_vfsmountedhere != NULL); 2693 } 2694 2695 /* Retrieve the vfs (if any) mounted on this vnode */ 2696 vfs_t * 2697 vn_mountedvfs(vnode_t *vp) 2698 { 2699 return (vp->v_vfsmountedhere); 2700 } 2701 2702 /* 2703 * Return nonzero if the vnode is referenced by the dnlc, zero if not. 2704 */ 2705 int 2706 vn_in_dnlc(vnode_t *vp) 2707 { 2708 return (vp->v_count_dnlc > 0); 2709 } 2710 2711 /* 2712 * vn_has_other_opens() checks whether a particular file is opened by more than 2713 * just the caller and whether the open is for read and/or write. 2714 * This routine is for calling after the caller has already called VOP_OPEN() 2715 * and the caller wishes to know if they are the only one with it open for 2716 * the mode(s) specified. 2717 * 2718 * Vnode counts are only kept on regular files (v_type=VREG). 2719 */ 2720 int 2721 vn_has_other_opens( 2722 vnode_t *vp, 2723 v_mode_t mode) 2724 { 2725 2726 ASSERT(vp != NULL); 2727 2728 switch (mode) { 2729 case V_WRITE: 2730 if (vp->v_wrcnt > 1) 2731 return (V_TRUE); 2732 break; 2733 case V_RDORWR: 2734 if ((vp->v_rdcnt > 1) || (vp->v_wrcnt > 1)) 2735 return (V_TRUE); 2736 break; 2737 case V_RDANDWR: 2738 if ((vp->v_rdcnt > 1) && (vp->v_wrcnt > 1)) 2739 return (V_TRUE); 2740 break; 2741 case V_READ: 2742 if (vp->v_rdcnt > 1) 2743 return (V_TRUE); 2744 break; 2745 } 2746 2747 return (V_FALSE); 2748 } 2749 2750 /* 2751 * vn_is_opened() checks whether a particular file is opened and 2752 * whether the open is for read and/or write. 2753 * 2754 * Vnode counts are only kept on regular files (v_type=VREG). 2755 */ 2756 int 2757 vn_is_opened( 2758 vnode_t *vp, 2759 v_mode_t mode) 2760 { 2761 2762 ASSERT(vp != NULL); 2763 2764 switch (mode) { 2765 case V_WRITE: 2766 if (vp->v_wrcnt) 2767 return (V_TRUE); 2768 break; 2769 case V_RDANDWR: 2770 if (vp->v_rdcnt && vp->v_wrcnt) 2771 return (V_TRUE); 2772 break; 2773 case V_RDORWR: 2774 if (vp->v_rdcnt || vp->v_wrcnt) 2775 return (V_TRUE); 2776 break; 2777 case V_READ: 2778 if (vp->v_rdcnt) 2779 return (V_TRUE); 2780 break; 2781 } 2782 2783 return (V_FALSE); 2784 } 2785 2786 /* 2787 * vn_is_mapped() checks whether a particular file is mapped and whether 2788 * the file is mapped read and/or write. 2789 */ 2790 int 2791 vn_is_mapped( 2792 vnode_t *vp, 2793 v_mode_t mode) 2794 { 2795 2796 ASSERT(vp != NULL); 2797 2798 #if !defined(_LP64) 2799 switch (mode) { 2800 /* 2801 * The atomic_add_64_nv functions force atomicity in the 2802 * case of 32 bit architectures. Otherwise the 64 bit values 2803 * require two fetches. The value of the fields may be 2804 * (potentially) changed between the first fetch and the 2805 * second 2806 */ 2807 case V_WRITE: 2808 if (atomic_add_64_nv((&(vp->v_mmap_write)), 0)) 2809 return (V_TRUE); 2810 break; 2811 case V_RDANDWR: 2812 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) && 2813 (atomic_add_64_nv((&(vp->v_mmap_write)), 0))) 2814 return (V_TRUE); 2815 break; 2816 case V_RDORWR: 2817 if ((atomic_add_64_nv((&(vp->v_mmap_read)), 0)) || 2818 (atomic_add_64_nv((&(vp->v_mmap_write)), 0))) 2819 return (V_TRUE); 2820 break; 2821 case V_READ: 2822 if (atomic_add_64_nv((&(vp->v_mmap_read)), 0)) 2823 return (V_TRUE); 2824 break; 2825 } 2826 #else 2827 switch (mode) { 2828 case V_WRITE: 2829 if (vp->v_mmap_write) 2830 return (V_TRUE); 2831 break; 2832 case V_RDANDWR: 2833 if (vp->v_mmap_read && vp->v_mmap_write) 2834 return (V_TRUE); 2835 break; 2836 case V_RDORWR: 2837 if (vp->v_mmap_read || vp->v_mmap_write) 2838 return (V_TRUE); 2839 break; 2840 case V_READ: 2841 if (vp->v_mmap_read) 2842 return (V_TRUE); 2843 break; 2844 } 2845 #endif 2846 2847 return (V_FALSE); 2848 } 2849 2850 /* 2851 * Set the operations vector for a vnode. 2852 * 2853 * FEM ensures that the v_femhead pointer is filled in before the 2854 * v_op pointer is changed. This means that if the v_femhead pointer 2855 * is NULL, and the v_op field hasn't changed since before which checked 2856 * the v_femhead pointer; then our update is ok - we are not racing with 2857 * FEM. 2858 */ 2859 void 2860 vn_setops(vnode_t *vp, vnodeops_t *vnodeops) 2861 { 2862 vnodeops_t *op; 2863 2864 ASSERT(vp != NULL); 2865 ASSERT(vnodeops != NULL); 2866 2867 op = vp->v_op; 2868 membar_consumer(); 2869 /* 2870 * If vp->v_femhead == NULL, then we'll call atomic_cas_ptr() to do 2871 * the compare-and-swap on vp->v_op. If either fails, then FEM is 2872 * in effect on the vnode and we need to have FEM deal with it. 2873 */ 2874 if (vp->v_femhead != NULL || atomic_cas_ptr(&vp->v_op, op, vnodeops) != 2875 op) { 2876 fem_setvnops(vp, vnodeops); 2877 } 2878 } 2879 2880 /* 2881 * Retrieve the operations vector for a vnode 2882 * As with vn_setops(above); make sure we aren't racing with FEM. 2883 * FEM sets the v_op to a special, internal, vnodeops that wouldn't 2884 * make sense to the callers of this routine. 2885 */ 2886 vnodeops_t * 2887 vn_getops(vnode_t *vp) 2888 { 2889 vnodeops_t *op; 2890 2891 ASSERT(vp != NULL); 2892 2893 op = vp->v_op; 2894 membar_consumer(); 2895 if (vp->v_femhead == NULL && op == vp->v_op) { 2896 return (op); 2897 } else { 2898 return (fem_getvnops(vp)); 2899 } 2900 } 2901 2902 /* 2903 * Returns non-zero (1) if the vnodeops matches that of the vnode. 2904 * Returns zero (0) if not. 2905 */ 2906 int 2907 vn_matchops(vnode_t *vp, vnodeops_t *vnodeops) 2908 { 2909 return (vn_getops(vp) == vnodeops); 2910 } 2911 2912 /* 2913 * Returns non-zero (1) if the specified operation matches the 2914 * corresponding operation for that the vnode. 2915 * Returns zero (0) if not. 2916 */ 2917 2918 #define MATCHNAME(n1, n2) (((n1)[0] == (n2)[0]) && (strcmp((n1), (n2)) == 0)) 2919 2920 int 2921 vn_matchopval(vnode_t *vp, char *vopname, fs_generic_func_p funcp) 2922 { 2923 const fs_operation_trans_def_t *otdp; 2924 fs_generic_func_p *loc = NULL; 2925 vnodeops_t *vop = vn_getops(vp); 2926 2927 ASSERT(vopname != NULL); 2928 2929 for (otdp = vn_ops_table; otdp->name != NULL; otdp++) { 2930 if (MATCHNAME(otdp->name, vopname)) { 2931 loc = (fs_generic_func_p *) 2932 ((char *)(vop) + otdp->offset); 2933 break; 2934 } 2935 } 2936 2937 return ((loc != NULL) && (*loc == funcp)); 2938 } 2939 2940 /* 2941 * fs_new_caller_id() needs to return a unique ID on a given local system. 2942 * The IDs do not need to survive across reboots. These are primarily 2943 * used so that (FEM) monitors can detect particular callers (such as 2944 * the NFS server) to a given vnode/vfs operation. 2945 */ 2946 u_longlong_t 2947 fs_new_caller_id() 2948 { 2949 static uint64_t next_caller_id = 0LL; /* First call returns 1 */ 2950 2951 return ((u_longlong_t)atomic_inc_64_nv(&next_caller_id)); 2952 } 2953 2954 /* 2955 * Given a starting vnode and a path, updates the path in the target vnode in 2956 * a safe manner. If the vnode already has path information embedded, then the 2957 * cached path is left untouched. 2958 */ 2959 2960 size_t max_vnode_path = 4 * MAXPATHLEN; 2961 2962 void 2963 vn_setpath(vnode_t *rootvp, struct vnode *startvp, struct vnode *vp, 2964 const char *path, size_t plen) 2965 { 2966 char *rpath; 2967 vnode_t *base; 2968 size_t rpathlen, rpathalloc; 2969 int doslash = 1; 2970 2971 if (*path == '/') { 2972 base = rootvp; 2973 path++; 2974 plen--; 2975 } else { 2976 base = startvp; 2977 } 2978 2979 /* 2980 * We cannot grab base->v_lock while we hold vp->v_lock because of 2981 * the potential for deadlock. 2982 */ 2983 mutex_enter(&base->v_lock); 2984 if (base->v_path == NULL) { 2985 mutex_exit(&base->v_lock); 2986 return; 2987 } 2988 2989 rpathlen = strlen(base->v_path); 2990 rpathalloc = rpathlen + plen + 1; 2991 /* Avoid adding a slash if there's already one there */ 2992 if (base->v_path[rpathlen-1] == '/') 2993 doslash = 0; 2994 else 2995 rpathalloc++; 2996 2997 /* 2998 * We don't want to call kmem_alloc(KM_SLEEP) with kernel locks held, 2999 * so we must do this dance. If, by chance, something changes the path, 3000 * just give up since there is no real harm. 3001 */ 3002 mutex_exit(&base->v_lock); 3003 3004 /* Paths should stay within reason */ 3005 if (rpathalloc > max_vnode_path) 3006 return; 3007 3008 rpath = kmem_alloc(rpathalloc, KM_SLEEP); 3009 3010 mutex_enter(&base->v_lock); 3011 if (base->v_path == NULL || strlen(base->v_path) != rpathlen) { 3012 mutex_exit(&base->v_lock); 3013 kmem_free(rpath, rpathalloc); 3014 return; 3015 } 3016 bcopy(base->v_path, rpath, rpathlen); 3017 mutex_exit(&base->v_lock); 3018 3019 if (doslash) 3020 rpath[rpathlen++] = '/'; 3021 bcopy(path, rpath + rpathlen, plen); 3022 rpath[rpathlen + plen] = '\0'; 3023 3024 mutex_enter(&vp->v_lock); 3025 if (vp->v_path != NULL) { 3026 mutex_exit(&vp->v_lock); 3027 kmem_free(rpath, rpathalloc); 3028 } else { 3029 vp->v_path = rpath; 3030 mutex_exit(&vp->v_lock); 3031 } 3032 } 3033 3034 /* 3035 * Sets the path to the vnode to be the given string, regardless of current 3036 * context. The string must be a complete path from rootdir. This is only used 3037 * by fsop_root() for setting the path based on the mountpoint. 3038 */ 3039 void 3040 vn_setpath_str(struct vnode *vp, const char *str, size_t len) 3041 { 3042 char *buf = kmem_alloc(len + 1, KM_SLEEP); 3043 3044 mutex_enter(&vp->v_lock); 3045 if (vp->v_path != NULL) { 3046 mutex_exit(&vp->v_lock); 3047 kmem_free(buf, len + 1); 3048 return; 3049 } 3050 3051 vp->v_path = buf; 3052 bcopy(str, vp->v_path, len); 3053 vp->v_path[len] = '\0'; 3054 3055 mutex_exit(&vp->v_lock); 3056 } 3057 3058 /* 3059 * Called from within filesystem's vop_rename() to handle renames once the 3060 * target vnode is available. 3061 */ 3062 void 3063 vn_renamepath(vnode_t *dvp, vnode_t *vp, const char *nm, size_t len) 3064 { 3065 char *tmp; 3066 3067 mutex_enter(&vp->v_lock); 3068 tmp = vp->v_path; 3069 vp->v_path = NULL; 3070 mutex_exit(&vp->v_lock); 3071 vn_setpath(rootdir, dvp, vp, nm, len); 3072 if (tmp != NULL) 3073 kmem_free(tmp, strlen(tmp) + 1); 3074 } 3075 3076 /* 3077 * Similar to vn_setpath_str(), this function sets the path of the destination 3078 * vnode to the be the same as the source vnode. 3079 */ 3080 void 3081 vn_copypath(struct vnode *src, struct vnode *dst) 3082 { 3083 char *buf; 3084 int alloc; 3085 3086 mutex_enter(&src->v_lock); 3087 if (src->v_path == NULL) { 3088 mutex_exit(&src->v_lock); 3089 return; 3090 } 3091 alloc = strlen(src->v_path) + 1; 3092 3093 /* avoid kmem_alloc() with lock held */ 3094 mutex_exit(&src->v_lock); 3095 buf = kmem_alloc(alloc, KM_SLEEP); 3096 mutex_enter(&src->v_lock); 3097 if (src->v_path == NULL || strlen(src->v_path) + 1 != alloc) { 3098 mutex_exit(&src->v_lock); 3099 kmem_free(buf, alloc); 3100 return; 3101 } 3102 bcopy(src->v_path, buf, alloc); 3103 mutex_exit(&src->v_lock); 3104 3105 mutex_enter(&dst->v_lock); 3106 if (dst->v_path != NULL) { 3107 mutex_exit(&dst->v_lock); 3108 kmem_free(buf, alloc); 3109 return; 3110 } 3111 dst->v_path = buf; 3112 mutex_exit(&dst->v_lock); 3113 } 3114 3115 /* 3116 * XXX Private interface for segvn routines that handle vnode 3117 * large page segments. 3118 * 3119 * return 1 if vp's file system VOP_PAGEIO() implementation 3120 * can be safely used instead of VOP_GETPAGE() for handling 3121 * pagefaults against regular non swap files. VOP_PAGEIO() 3122 * interface is considered safe here if its implementation 3123 * is very close to VOP_GETPAGE() implementation. 3124 * e.g. It zero's out the part of the page beyond EOF. Doesn't 3125 * panic if there're file holes but instead returns an error. 3126 * Doesn't assume file won't be changed by user writes, etc. 3127 * 3128 * return 0 otherwise. 3129 * 3130 * For now allow segvn to only use VOP_PAGEIO() with ufs and nfs. 3131 */ 3132 int 3133 vn_vmpss_usepageio(vnode_t *vp) 3134 { 3135 vfs_t *vfsp = vp->v_vfsp; 3136 char *fsname = vfssw[vfsp->vfs_fstype].vsw_name; 3137 char *pageio_ok_fss[] = {"ufs", "nfs", NULL}; 3138 char **fsok = pageio_ok_fss; 3139 3140 if (fsname == NULL) { 3141 return (0); 3142 } 3143 3144 for (; *fsok; fsok++) { 3145 if (strcmp(*fsok, fsname) == 0) { 3146 return (1); 3147 } 3148 } 3149 return (0); 3150 } 3151 3152 /* VOP_XXX() macros call the corresponding fop_xxx() function */ 3153 3154 int 3155 fop_open( 3156 vnode_t **vpp, 3157 int mode, 3158 cred_t *cr, 3159 caller_context_t *ct) 3160 { 3161 int ret; 3162 vnode_t *vp = *vpp; 3163 3164 VN_HOLD(vp); 3165 /* 3166 * Adding to the vnode counts before calling open 3167 * avoids the need for a mutex. It circumvents a race 3168 * condition where a query made on the vnode counts results in a 3169 * false negative. The inquirer goes away believing the file is 3170 * not open when there is an open on the file already under way. 3171 * 3172 * The counts are meant to prevent NFS from granting a delegation 3173 * when it would be dangerous to do so. 3174 * 3175 * The vnode counts are only kept on regular files 3176 */ 3177 if ((*vpp)->v_type == VREG) { 3178 if (mode & FREAD) 3179 atomic_inc_32(&(*vpp)->v_rdcnt); 3180 if (mode & FWRITE) 3181 atomic_inc_32(&(*vpp)->v_wrcnt); 3182 } 3183 3184 VOPXID_MAP_CR(vp, cr); 3185 3186 ret = (*(*(vpp))->v_op->vop_open)(vpp, mode, cr, ct); 3187 3188 if (ret) { 3189 /* 3190 * Use the saved vp just in case the vnode ptr got trashed 3191 * by the error. 3192 */ 3193 VOPSTATS_UPDATE(vp, open); 3194 if ((vp->v_type == VREG) && (mode & FREAD)) 3195 atomic_dec_32(&vp->v_rdcnt); 3196 if ((vp->v_type == VREG) && (mode & FWRITE)) 3197 atomic_dec_32(&vp->v_wrcnt); 3198 } else { 3199 /* 3200 * Some filesystems will return a different vnode, 3201 * but the same path was still used to open it. 3202 * So if we do change the vnode and need to 3203 * copy over the path, do so here, rather than special 3204 * casing each filesystem. Adjust the vnode counts to 3205 * reflect the vnode switch. 3206 */ 3207 VOPSTATS_UPDATE(*vpp, open); 3208 if (*vpp != vp && *vpp != NULL) { 3209 vn_copypath(vp, *vpp); 3210 if (((*vpp)->v_type == VREG) && (mode & FREAD)) 3211 atomic_inc_32(&(*vpp)->v_rdcnt); 3212 if ((vp->v_type == VREG) && (mode & FREAD)) 3213 atomic_dec_32(&vp->v_rdcnt); 3214 if (((*vpp)->v_type == VREG) && (mode & FWRITE)) 3215 atomic_inc_32(&(*vpp)->v_wrcnt); 3216 if ((vp->v_type == VREG) && (mode & FWRITE)) 3217 atomic_dec_32(&vp->v_wrcnt); 3218 } 3219 } 3220 VN_RELE(vp); 3221 return (ret); 3222 } 3223 3224 int 3225 fop_close( 3226 vnode_t *vp, 3227 int flag, 3228 int count, 3229 offset_t offset, 3230 cred_t *cr, 3231 caller_context_t *ct) 3232 { 3233 int err; 3234 3235 VOPXID_MAP_CR(vp, cr); 3236 3237 err = (*(vp)->v_op->vop_close)(vp, flag, count, offset, cr, ct); 3238 VOPSTATS_UPDATE(vp, close); 3239 /* 3240 * Check passed in count to handle possible dups. Vnode counts are only 3241 * kept on regular files 3242 */ 3243 if ((vp->v_type == VREG) && (count == 1)) { 3244 if (flag & FREAD) { 3245 ASSERT(vp->v_rdcnt > 0); 3246 atomic_dec_32(&vp->v_rdcnt); 3247 } 3248 if (flag & FWRITE) { 3249 ASSERT(vp->v_wrcnt > 0); 3250 atomic_dec_32(&vp->v_wrcnt); 3251 } 3252 } 3253 return (err); 3254 } 3255 3256 int 3257 fop_read( 3258 vnode_t *vp, 3259 uio_t *uiop, 3260 int ioflag, 3261 cred_t *cr, 3262 caller_context_t *ct) 3263 { 3264 int err; 3265 ssize_t resid_start = uiop->uio_resid; 3266 3267 VOPXID_MAP_CR(vp, cr); 3268 3269 err = (*(vp)->v_op->vop_read)(vp, uiop, ioflag, cr, ct); 3270 VOPSTATS_UPDATE_IO(vp, read, 3271 read_bytes, (resid_start - uiop->uio_resid)); 3272 return (err); 3273 } 3274 3275 int 3276 fop_write( 3277 vnode_t *vp, 3278 uio_t *uiop, 3279 int ioflag, 3280 cred_t *cr, 3281 caller_context_t *ct) 3282 { 3283 int err; 3284 ssize_t resid_start = uiop->uio_resid; 3285 3286 VOPXID_MAP_CR(vp, cr); 3287 3288 err = (*(vp)->v_op->vop_write)(vp, uiop, ioflag, cr, ct); 3289 VOPSTATS_UPDATE_IO(vp, write, 3290 write_bytes, (resid_start - uiop->uio_resid)); 3291 return (err); 3292 } 3293 3294 int 3295 fop_ioctl( 3296 vnode_t *vp, 3297 int cmd, 3298 intptr_t arg, 3299 int flag, 3300 cred_t *cr, 3301 int *rvalp, 3302 caller_context_t *ct) 3303 { 3304 int err; 3305 3306 VOPXID_MAP_CR(vp, cr); 3307 3308 err = (*(vp)->v_op->vop_ioctl)(vp, cmd, arg, flag, cr, rvalp, ct); 3309 VOPSTATS_UPDATE(vp, ioctl); 3310 return (err); 3311 } 3312 3313 int 3314 fop_setfl( 3315 vnode_t *vp, 3316 int oflags, 3317 int nflags, 3318 cred_t *cr, 3319 caller_context_t *ct) 3320 { 3321 int err; 3322 3323 VOPXID_MAP_CR(vp, cr); 3324 3325 err = (*(vp)->v_op->vop_setfl)(vp, oflags, nflags, cr, ct); 3326 VOPSTATS_UPDATE(vp, setfl); 3327 return (err); 3328 } 3329 3330 int 3331 fop_getattr( 3332 vnode_t *vp, 3333 vattr_t *vap, 3334 int flags, 3335 cred_t *cr, 3336 caller_context_t *ct) 3337 { 3338 int err; 3339 3340 VOPXID_MAP_CR(vp, cr); 3341 3342 /* 3343 * If this file system doesn't understand the xvattr extensions 3344 * then turn off the xvattr bit. 3345 */ 3346 if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) { 3347 vap->va_mask &= ~AT_XVATTR; 3348 } 3349 3350 /* 3351 * We're only allowed to skip the ACL check iff we used a 32 bit 3352 * ACE mask with VOP_ACCESS() to determine permissions. 3353 */ 3354 if ((flags & ATTR_NOACLCHECK) && 3355 vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) { 3356 return (EINVAL); 3357 } 3358 err = (*(vp)->v_op->vop_getattr)(vp, vap, flags, cr, ct); 3359 VOPSTATS_UPDATE(vp, getattr); 3360 return (err); 3361 } 3362 3363 int 3364 fop_setattr( 3365 vnode_t *vp, 3366 vattr_t *vap, 3367 int flags, 3368 cred_t *cr, 3369 caller_context_t *ct) 3370 { 3371 int err; 3372 3373 VOPXID_MAP_CR(vp, cr); 3374 3375 /* 3376 * If this file system doesn't understand the xvattr extensions 3377 * then turn off the xvattr bit. 3378 */ 3379 if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) { 3380 vap->va_mask &= ~AT_XVATTR; 3381 } 3382 3383 /* 3384 * We're only allowed to skip the ACL check iff we used a 32 bit 3385 * ACE mask with VOP_ACCESS() to determine permissions. 3386 */ 3387 if ((flags & ATTR_NOACLCHECK) && 3388 vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) { 3389 return (EINVAL); 3390 } 3391 err = (*(vp)->v_op->vop_setattr)(vp, vap, flags, cr, ct); 3392 VOPSTATS_UPDATE(vp, setattr); 3393 return (err); 3394 } 3395 3396 int 3397 fop_access( 3398 vnode_t *vp, 3399 int mode, 3400 int flags, 3401 cred_t *cr, 3402 caller_context_t *ct) 3403 { 3404 int err; 3405 3406 if ((flags & V_ACE_MASK) && 3407 vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) { 3408 return (EINVAL); 3409 } 3410 3411 VOPXID_MAP_CR(vp, cr); 3412 3413 err = (*(vp)->v_op->vop_access)(vp, mode, flags, cr, ct); 3414 VOPSTATS_UPDATE(vp, access); 3415 return (err); 3416 } 3417 3418 int 3419 fop_lookup( 3420 vnode_t *dvp, 3421 char *nm, 3422 vnode_t **vpp, 3423 pathname_t *pnp, 3424 int flags, 3425 vnode_t *rdir, 3426 cred_t *cr, 3427 caller_context_t *ct, 3428 int *deflags, /* Returned per-dirent flags */ 3429 pathname_t *ppnp) /* Returned case-preserved name in directory */ 3430 { 3431 int ret; 3432 3433 /* 3434 * If this file system doesn't support case-insensitive access 3435 * and said access is requested, fail quickly. It is required 3436 * that if the vfs supports case-insensitive lookup, it also 3437 * supports extended dirent flags. 3438 */ 3439 if (flags & FIGNORECASE && 3440 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3441 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3442 return (EINVAL); 3443 3444 VOPXID_MAP_CR(dvp, cr); 3445 3446 if ((flags & LOOKUP_XATTR) && (flags & LOOKUP_HAVE_SYSATTR_DIR) == 0) { 3447 ret = xattr_dir_lookup(dvp, vpp, flags, cr); 3448 } else { 3449 ret = (*(dvp)->v_op->vop_lookup) 3450 (dvp, nm, vpp, pnp, flags, rdir, cr, ct, deflags, ppnp); 3451 } 3452 if (ret == 0 && *vpp) { 3453 VOPSTATS_UPDATE(*vpp, lookup); 3454 if ((*vpp)->v_path == NULL) { 3455 vn_setpath(rootdir, dvp, *vpp, nm, strlen(nm)); 3456 } 3457 } 3458 3459 return (ret); 3460 } 3461 3462 int 3463 fop_create( 3464 vnode_t *dvp, 3465 char *name, 3466 vattr_t *vap, 3467 vcexcl_t excl, 3468 int mode, 3469 vnode_t **vpp, 3470 cred_t *cr, 3471 int flags, 3472 caller_context_t *ct, 3473 vsecattr_t *vsecp) /* ACL to set during create */ 3474 { 3475 int ret; 3476 3477 if (vsecp != NULL && 3478 vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) { 3479 return (EINVAL); 3480 } 3481 /* 3482 * If this file system doesn't support case-insensitive access 3483 * and said access is requested, fail quickly. 3484 */ 3485 if (flags & FIGNORECASE && 3486 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3487 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3488 return (EINVAL); 3489 3490 VOPXID_MAP_CR(dvp, cr); 3491 3492 ret = (*(dvp)->v_op->vop_create) 3493 (dvp, name, vap, excl, mode, vpp, cr, flags, ct, vsecp); 3494 if (ret == 0 && *vpp) { 3495 VOPSTATS_UPDATE(*vpp, create); 3496 if ((*vpp)->v_path == NULL) { 3497 vn_setpath(rootdir, dvp, *vpp, name, strlen(name)); 3498 } 3499 } 3500 3501 return (ret); 3502 } 3503 3504 int 3505 fop_remove( 3506 vnode_t *dvp, 3507 char *nm, 3508 cred_t *cr, 3509 caller_context_t *ct, 3510 int flags) 3511 { 3512 int err; 3513 3514 /* 3515 * If this file system doesn't support case-insensitive access 3516 * and said access is requested, fail quickly. 3517 */ 3518 if (flags & FIGNORECASE && 3519 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3520 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3521 return (EINVAL); 3522 3523 VOPXID_MAP_CR(dvp, cr); 3524 3525 err = (*(dvp)->v_op->vop_remove)(dvp, nm, cr, ct, flags); 3526 VOPSTATS_UPDATE(dvp, remove); 3527 return (err); 3528 } 3529 3530 int 3531 fop_link( 3532 vnode_t *tdvp, 3533 vnode_t *svp, 3534 char *tnm, 3535 cred_t *cr, 3536 caller_context_t *ct, 3537 int flags) 3538 { 3539 int err; 3540 3541 /* 3542 * If the target file system doesn't support case-insensitive access 3543 * and said access is requested, fail quickly. 3544 */ 3545 if (flags & FIGNORECASE && 3546 (vfs_has_feature(tdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3547 vfs_has_feature(tdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3548 return (EINVAL); 3549 3550 VOPXID_MAP_CR(tdvp, cr); 3551 3552 err = (*(tdvp)->v_op->vop_link)(tdvp, svp, tnm, cr, ct, flags); 3553 VOPSTATS_UPDATE(tdvp, link); 3554 return (err); 3555 } 3556 3557 int 3558 fop_rename( 3559 vnode_t *sdvp, 3560 char *snm, 3561 vnode_t *tdvp, 3562 char *tnm, 3563 cred_t *cr, 3564 caller_context_t *ct, 3565 int flags) 3566 { 3567 int err; 3568 3569 /* 3570 * If the file system involved does not support 3571 * case-insensitive access and said access is requested, fail 3572 * quickly. 3573 */ 3574 if (flags & FIGNORECASE && 3575 ((vfs_has_feature(sdvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3576 vfs_has_feature(sdvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0))) 3577 return (EINVAL); 3578 3579 VOPXID_MAP_CR(tdvp, cr); 3580 3581 err = (*(sdvp)->v_op->vop_rename)(sdvp, snm, tdvp, tnm, cr, ct, flags); 3582 VOPSTATS_UPDATE(sdvp, rename); 3583 return (err); 3584 } 3585 3586 int 3587 fop_mkdir( 3588 vnode_t *dvp, 3589 char *dirname, 3590 vattr_t *vap, 3591 vnode_t **vpp, 3592 cred_t *cr, 3593 caller_context_t *ct, 3594 int flags, 3595 vsecattr_t *vsecp) /* ACL to set during create */ 3596 { 3597 int ret; 3598 3599 if (vsecp != NULL && 3600 vfs_has_feature(dvp->v_vfsp, VFSFT_ACLONCREATE) == 0) { 3601 return (EINVAL); 3602 } 3603 /* 3604 * If this file system doesn't support case-insensitive access 3605 * and said access is requested, fail quickly. 3606 */ 3607 if (flags & FIGNORECASE && 3608 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3609 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3610 return (EINVAL); 3611 3612 VOPXID_MAP_CR(dvp, cr); 3613 3614 ret = (*(dvp)->v_op->vop_mkdir) 3615 (dvp, dirname, vap, vpp, cr, ct, flags, vsecp); 3616 if (ret == 0 && *vpp) { 3617 VOPSTATS_UPDATE(*vpp, mkdir); 3618 if ((*vpp)->v_path == NULL) { 3619 vn_setpath(rootdir, dvp, *vpp, dirname, 3620 strlen(dirname)); 3621 } 3622 } 3623 3624 return (ret); 3625 } 3626 3627 int 3628 fop_rmdir( 3629 vnode_t *dvp, 3630 char *nm, 3631 vnode_t *cdir, 3632 cred_t *cr, 3633 caller_context_t *ct, 3634 int flags) 3635 { 3636 int err; 3637 3638 /* 3639 * If this file system doesn't support case-insensitive access 3640 * and said access is requested, fail quickly. 3641 */ 3642 if (flags & FIGNORECASE && 3643 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3644 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3645 return (EINVAL); 3646 3647 VOPXID_MAP_CR(dvp, cr); 3648 3649 err = (*(dvp)->v_op->vop_rmdir)(dvp, nm, cdir, cr, ct, flags); 3650 VOPSTATS_UPDATE(dvp, rmdir); 3651 return (err); 3652 } 3653 3654 int 3655 fop_readdir( 3656 vnode_t *vp, 3657 uio_t *uiop, 3658 cred_t *cr, 3659 int *eofp, 3660 caller_context_t *ct, 3661 int flags) 3662 { 3663 int err; 3664 ssize_t resid_start = uiop->uio_resid; 3665 3666 /* 3667 * If this file system doesn't support retrieving directory 3668 * entry flags and said access is requested, fail quickly. 3669 */ 3670 if (flags & V_RDDIR_ENTFLAGS && 3671 vfs_has_feature(vp->v_vfsp, VFSFT_DIRENTFLAGS) == 0) 3672 return (EINVAL); 3673 3674 VOPXID_MAP_CR(vp, cr); 3675 3676 err = (*(vp)->v_op->vop_readdir)(vp, uiop, cr, eofp, ct, flags); 3677 VOPSTATS_UPDATE_IO(vp, readdir, 3678 readdir_bytes, (resid_start - uiop->uio_resid)); 3679 return (err); 3680 } 3681 3682 int 3683 fop_symlink( 3684 vnode_t *dvp, 3685 char *linkname, 3686 vattr_t *vap, 3687 char *target, 3688 cred_t *cr, 3689 caller_context_t *ct, 3690 int flags) 3691 { 3692 int err; 3693 xvattr_t xvattr; 3694 3695 /* 3696 * If this file system doesn't support case-insensitive access 3697 * and said access is requested, fail quickly. 3698 */ 3699 if (flags & FIGNORECASE && 3700 (vfs_has_feature(dvp->v_vfsp, VFSFT_CASEINSENSITIVE) == 0 && 3701 vfs_has_feature(dvp->v_vfsp, VFSFT_NOCASESENSITIVE) == 0)) 3702 return (EINVAL); 3703 3704 VOPXID_MAP_CR(dvp, cr); 3705 3706 /* check for reparse point */ 3707 if ((vfs_has_feature(dvp->v_vfsp, VFSFT_REPARSE)) && 3708 (strncmp(target, FS_REPARSE_TAG_STR, 3709 strlen(FS_REPARSE_TAG_STR)) == 0)) { 3710 if (!fs_reparse_mark(target, vap, &xvattr)) 3711 vap = (vattr_t *)&xvattr; 3712 } 3713 3714 err = (*(dvp)->v_op->vop_symlink) 3715 (dvp, linkname, vap, target, cr, ct, flags); 3716 VOPSTATS_UPDATE(dvp, symlink); 3717 return (err); 3718 } 3719 3720 int 3721 fop_readlink( 3722 vnode_t *vp, 3723 uio_t *uiop, 3724 cred_t *cr, 3725 caller_context_t *ct) 3726 { 3727 int err; 3728 3729 VOPXID_MAP_CR(vp, cr); 3730 3731 err = (*(vp)->v_op->vop_readlink)(vp, uiop, cr, ct); 3732 VOPSTATS_UPDATE(vp, readlink); 3733 return (err); 3734 } 3735 3736 int 3737 fop_fsync( 3738 vnode_t *vp, 3739 int syncflag, 3740 cred_t *cr, 3741 caller_context_t *ct) 3742 { 3743 int err; 3744 3745 VOPXID_MAP_CR(vp, cr); 3746 3747 err = (*(vp)->v_op->vop_fsync)(vp, syncflag, cr, ct); 3748 VOPSTATS_UPDATE(vp, fsync); 3749 return (err); 3750 } 3751 3752 void 3753 fop_inactive( 3754 vnode_t *vp, 3755 cred_t *cr, 3756 caller_context_t *ct) 3757 { 3758 /* Need to update stats before vop call since we may lose the vnode */ 3759 VOPSTATS_UPDATE(vp, inactive); 3760 3761 VOPXID_MAP_CR(vp, cr); 3762 3763 (*(vp)->v_op->vop_inactive)(vp, cr, ct); 3764 } 3765 3766 int 3767 fop_fid( 3768 vnode_t *vp, 3769 fid_t *fidp, 3770 caller_context_t *ct) 3771 { 3772 int err; 3773 3774 err = (*(vp)->v_op->vop_fid)(vp, fidp, ct); 3775 VOPSTATS_UPDATE(vp, fid); 3776 return (err); 3777 } 3778 3779 int 3780 fop_rwlock( 3781 vnode_t *vp, 3782 int write_lock, 3783 caller_context_t *ct) 3784 { 3785 int ret; 3786 3787 ret = ((*(vp)->v_op->vop_rwlock)(vp, write_lock, ct)); 3788 VOPSTATS_UPDATE(vp, rwlock); 3789 return (ret); 3790 } 3791 3792 void 3793 fop_rwunlock( 3794 vnode_t *vp, 3795 int write_lock, 3796 caller_context_t *ct) 3797 { 3798 (*(vp)->v_op->vop_rwunlock)(vp, write_lock, ct); 3799 VOPSTATS_UPDATE(vp, rwunlock); 3800 } 3801 3802 int 3803 fop_seek( 3804 vnode_t *vp, 3805 offset_t ooff, 3806 offset_t *noffp, 3807 caller_context_t *ct) 3808 { 3809 int err; 3810 3811 err = (*(vp)->v_op->vop_seek)(vp, ooff, noffp, ct); 3812 VOPSTATS_UPDATE(vp, seek); 3813 return (err); 3814 } 3815 3816 int 3817 fop_cmp( 3818 vnode_t *vp1, 3819 vnode_t *vp2, 3820 caller_context_t *ct) 3821 { 3822 int err; 3823 3824 err = (*(vp1)->v_op->vop_cmp)(vp1, vp2, ct); 3825 VOPSTATS_UPDATE(vp1, cmp); 3826 return (err); 3827 } 3828 3829 int 3830 fop_frlock( 3831 vnode_t *vp, 3832 int cmd, 3833 flock64_t *bfp, 3834 int flag, 3835 offset_t offset, 3836 struct flk_callback *flk_cbp, 3837 cred_t *cr, 3838 caller_context_t *ct) 3839 { 3840 int err; 3841 3842 VOPXID_MAP_CR(vp, cr); 3843 3844 err = (*(vp)->v_op->vop_frlock) 3845 (vp, cmd, bfp, flag, offset, flk_cbp, cr, ct); 3846 VOPSTATS_UPDATE(vp, frlock); 3847 return (err); 3848 } 3849 3850 int 3851 fop_space( 3852 vnode_t *vp, 3853 int cmd, 3854 flock64_t *bfp, 3855 int flag, 3856 offset_t offset, 3857 cred_t *cr, 3858 caller_context_t *ct) 3859 { 3860 int err; 3861 3862 VOPXID_MAP_CR(vp, cr); 3863 3864 err = (*(vp)->v_op->vop_space)(vp, cmd, bfp, flag, offset, cr, ct); 3865 VOPSTATS_UPDATE(vp, space); 3866 return (err); 3867 } 3868 3869 int 3870 fop_realvp( 3871 vnode_t *vp, 3872 vnode_t **vpp, 3873 caller_context_t *ct) 3874 { 3875 int err; 3876 3877 err = (*(vp)->v_op->vop_realvp)(vp, vpp, ct); 3878 VOPSTATS_UPDATE(vp, realvp); 3879 return (err); 3880 } 3881 3882 int 3883 fop_getpage( 3884 vnode_t *vp, 3885 offset_t off, 3886 size_t len, 3887 uint_t *protp, 3888 page_t **plarr, 3889 size_t plsz, 3890 struct seg *seg, 3891 caddr_t addr, 3892 enum seg_rw rw, 3893 cred_t *cr, 3894 caller_context_t *ct) 3895 { 3896 int err; 3897 3898 VOPXID_MAP_CR(vp, cr); 3899 3900 err = (*(vp)->v_op->vop_getpage) 3901 (vp, off, len, protp, plarr, plsz, seg, addr, rw, cr, ct); 3902 VOPSTATS_UPDATE(vp, getpage); 3903 return (err); 3904 } 3905 3906 int 3907 fop_putpage( 3908 vnode_t *vp, 3909 offset_t off, 3910 size_t len, 3911 int flags, 3912 cred_t *cr, 3913 caller_context_t *ct) 3914 { 3915 int err; 3916 3917 VOPXID_MAP_CR(vp, cr); 3918 3919 err = (*(vp)->v_op->vop_putpage)(vp, off, len, flags, cr, ct); 3920 VOPSTATS_UPDATE(vp, putpage); 3921 return (err); 3922 } 3923 3924 int 3925 fop_map( 3926 vnode_t *vp, 3927 offset_t off, 3928 struct as *as, 3929 caddr_t *addrp, 3930 size_t len, 3931 uchar_t prot, 3932 uchar_t maxprot, 3933 uint_t flags, 3934 cred_t *cr, 3935 caller_context_t *ct) 3936 { 3937 int err; 3938 3939 VOPXID_MAP_CR(vp, cr); 3940 3941 err = (*(vp)->v_op->vop_map) 3942 (vp, off, as, addrp, len, prot, maxprot, flags, cr, ct); 3943 VOPSTATS_UPDATE(vp, map); 3944 return (err); 3945 } 3946 3947 int 3948 fop_addmap( 3949 vnode_t *vp, 3950 offset_t off, 3951 struct as *as, 3952 caddr_t addr, 3953 size_t len, 3954 uchar_t prot, 3955 uchar_t maxprot, 3956 uint_t flags, 3957 cred_t *cr, 3958 caller_context_t *ct) 3959 { 3960 int error; 3961 u_longlong_t delta; 3962 3963 VOPXID_MAP_CR(vp, cr); 3964 3965 error = (*(vp)->v_op->vop_addmap) 3966 (vp, off, as, addr, len, prot, maxprot, flags, cr, ct); 3967 3968 if ((!error) && (vp->v_type == VREG)) { 3969 delta = (u_longlong_t)btopr(len); 3970 /* 3971 * If file is declared MAP_PRIVATE, it can't be written back 3972 * even if open for write. Handle as read. 3973 */ 3974 if (flags & MAP_PRIVATE) { 3975 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 3976 (int64_t)delta); 3977 } else { 3978 /* 3979 * atomic_add_64 forces the fetch of a 64 bit value to 3980 * be atomic on 32 bit machines 3981 */ 3982 if (maxprot & PROT_WRITE) 3983 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)), 3984 (int64_t)delta); 3985 if (maxprot & PROT_READ) 3986 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 3987 (int64_t)delta); 3988 if (maxprot & PROT_EXEC) 3989 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 3990 (int64_t)delta); 3991 } 3992 } 3993 VOPSTATS_UPDATE(vp, addmap); 3994 return (error); 3995 } 3996 3997 int 3998 fop_delmap( 3999 vnode_t *vp, 4000 offset_t off, 4001 struct as *as, 4002 caddr_t addr, 4003 size_t len, 4004 uint_t prot, 4005 uint_t maxprot, 4006 uint_t flags, 4007 cred_t *cr, 4008 caller_context_t *ct) 4009 { 4010 int error; 4011 u_longlong_t delta; 4012 4013 VOPXID_MAP_CR(vp, cr); 4014 4015 error = (*(vp)->v_op->vop_delmap) 4016 (vp, off, as, addr, len, prot, maxprot, flags, cr, ct); 4017 4018 /* 4019 * NFS calls into delmap twice, the first time 4020 * it simply establishes a callback mechanism and returns EAGAIN 4021 * while the real work is being done upon the second invocation. 4022 * We have to detect this here and only decrement the counts upon 4023 * the second delmap request. 4024 */ 4025 if ((error != EAGAIN) && (vp->v_type == VREG)) { 4026 4027 delta = (u_longlong_t)btopr(len); 4028 4029 if (flags & MAP_PRIVATE) { 4030 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 4031 (int64_t)(-delta)); 4032 } else { 4033 /* 4034 * atomic_add_64 forces the fetch of a 64 bit value 4035 * to be atomic on 32 bit machines 4036 */ 4037 if (maxprot & PROT_WRITE) 4038 atomic_add_64((uint64_t *)(&(vp->v_mmap_write)), 4039 (int64_t)(-delta)); 4040 if (maxprot & PROT_READ) 4041 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 4042 (int64_t)(-delta)); 4043 if (maxprot & PROT_EXEC) 4044 atomic_add_64((uint64_t *)(&(vp->v_mmap_read)), 4045 (int64_t)(-delta)); 4046 } 4047 } 4048 VOPSTATS_UPDATE(vp, delmap); 4049 return (error); 4050 } 4051 4052 4053 int 4054 fop_poll( 4055 vnode_t *vp, 4056 short events, 4057 int anyyet, 4058 short *reventsp, 4059 struct pollhead **phpp, 4060 caller_context_t *ct) 4061 { 4062 int err; 4063 4064 err = (*(vp)->v_op->vop_poll)(vp, events, anyyet, reventsp, phpp, ct); 4065 VOPSTATS_UPDATE(vp, poll); 4066 return (err); 4067 } 4068 4069 int 4070 fop_dump( 4071 vnode_t *vp, 4072 caddr_t addr, 4073 offset_t lbdn, 4074 offset_t dblks, 4075 caller_context_t *ct) 4076 { 4077 int err; 4078 4079 /* ensure lbdn and dblks can be passed safely to bdev_dump */ 4080 if ((lbdn != (daddr_t)lbdn) || (dblks != (int)dblks)) 4081 return (EIO); 4082 4083 err = (*(vp)->v_op->vop_dump)(vp, addr, lbdn, dblks, ct); 4084 VOPSTATS_UPDATE(vp, dump); 4085 return (err); 4086 } 4087 4088 int 4089 fop_pathconf( 4090 vnode_t *vp, 4091 int cmd, 4092 ulong_t *valp, 4093 cred_t *cr, 4094 caller_context_t *ct) 4095 { 4096 int err; 4097 4098 VOPXID_MAP_CR(vp, cr); 4099 4100 err = (*(vp)->v_op->vop_pathconf)(vp, cmd, valp, cr, ct); 4101 VOPSTATS_UPDATE(vp, pathconf); 4102 return (err); 4103 } 4104 4105 int 4106 fop_pageio( 4107 vnode_t *vp, 4108 struct page *pp, 4109 u_offset_t io_off, 4110 size_t io_len, 4111 int flags, 4112 cred_t *cr, 4113 caller_context_t *ct) 4114 { 4115 int err; 4116 4117 VOPXID_MAP_CR(vp, cr); 4118 4119 err = (*(vp)->v_op->vop_pageio)(vp, pp, io_off, io_len, flags, cr, ct); 4120 VOPSTATS_UPDATE(vp, pageio); 4121 return (err); 4122 } 4123 4124 int 4125 fop_dumpctl( 4126 vnode_t *vp, 4127 int action, 4128 offset_t *blkp, 4129 caller_context_t *ct) 4130 { 4131 int err; 4132 err = (*(vp)->v_op->vop_dumpctl)(vp, action, blkp, ct); 4133 VOPSTATS_UPDATE(vp, dumpctl); 4134 return (err); 4135 } 4136 4137 void 4138 fop_dispose( 4139 vnode_t *vp, 4140 page_t *pp, 4141 int flag, 4142 int dn, 4143 cred_t *cr, 4144 caller_context_t *ct) 4145 { 4146 /* Must do stats first since it's possible to lose the vnode */ 4147 VOPSTATS_UPDATE(vp, dispose); 4148 4149 VOPXID_MAP_CR(vp, cr); 4150 4151 (*(vp)->v_op->vop_dispose)(vp, pp, flag, dn, cr, ct); 4152 } 4153 4154 int 4155 fop_setsecattr( 4156 vnode_t *vp, 4157 vsecattr_t *vsap, 4158 int flag, 4159 cred_t *cr, 4160 caller_context_t *ct) 4161 { 4162 int err; 4163 4164 VOPXID_MAP_CR(vp, cr); 4165 4166 /* 4167 * We're only allowed to skip the ACL check iff we used a 32 bit 4168 * ACE mask with VOP_ACCESS() to determine permissions. 4169 */ 4170 if ((flag & ATTR_NOACLCHECK) && 4171 vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) { 4172 return (EINVAL); 4173 } 4174 err = (*(vp)->v_op->vop_setsecattr) (vp, vsap, flag, cr, ct); 4175 VOPSTATS_UPDATE(vp, setsecattr); 4176 return (err); 4177 } 4178 4179 int 4180 fop_getsecattr( 4181 vnode_t *vp, 4182 vsecattr_t *vsap, 4183 int flag, 4184 cred_t *cr, 4185 caller_context_t *ct) 4186 { 4187 int err; 4188 4189 /* 4190 * We're only allowed to skip the ACL check iff we used a 32 bit 4191 * ACE mask with VOP_ACCESS() to determine permissions. 4192 */ 4193 if ((flag & ATTR_NOACLCHECK) && 4194 vfs_has_feature(vp->v_vfsp, VFSFT_ACEMASKONACCESS) == 0) { 4195 return (EINVAL); 4196 } 4197 4198 VOPXID_MAP_CR(vp, cr); 4199 4200 err = (*(vp)->v_op->vop_getsecattr) (vp, vsap, flag, cr, ct); 4201 VOPSTATS_UPDATE(vp, getsecattr); 4202 return (err); 4203 } 4204 4205 int 4206 fop_shrlock( 4207 vnode_t *vp, 4208 int cmd, 4209 struct shrlock *shr, 4210 int flag, 4211 cred_t *cr, 4212 caller_context_t *ct) 4213 { 4214 int err; 4215 4216 VOPXID_MAP_CR(vp, cr); 4217 4218 err = (*(vp)->v_op->vop_shrlock)(vp, cmd, shr, flag, cr, ct); 4219 VOPSTATS_UPDATE(vp, shrlock); 4220 return (err); 4221 } 4222 4223 int 4224 fop_vnevent(vnode_t *vp, vnevent_t vnevent, vnode_t *dvp, char *fnm, 4225 caller_context_t *ct) 4226 { 4227 int err; 4228 4229 err = (*(vp)->v_op->vop_vnevent)(vp, vnevent, dvp, fnm, ct); 4230 VOPSTATS_UPDATE(vp, vnevent); 4231 return (err); 4232 } 4233 4234 int 4235 fop_reqzcbuf(vnode_t *vp, enum uio_rw ioflag, xuio_t *uiop, cred_t *cr, 4236 caller_context_t *ct) 4237 { 4238 int err; 4239 4240 if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0) 4241 return (ENOTSUP); 4242 err = (*(vp)->v_op->vop_reqzcbuf)(vp, ioflag, uiop, cr, ct); 4243 VOPSTATS_UPDATE(vp, reqzcbuf); 4244 return (err); 4245 } 4246 4247 int 4248 fop_retzcbuf(vnode_t *vp, xuio_t *uiop, cred_t *cr, caller_context_t *ct) 4249 { 4250 int err; 4251 4252 if (vfs_has_feature(vp->v_vfsp, VFSFT_ZEROCOPY_SUPPORTED) == 0) 4253 return (ENOTSUP); 4254 err = (*(vp)->v_op->vop_retzcbuf)(vp, uiop, cr, ct); 4255 VOPSTATS_UPDATE(vp, retzcbuf); 4256 return (err); 4257 } 4258 4259 /* 4260 * Default destructor 4261 * Needed because NULL destructor means that the key is unused 4262 */ 4263 /* ARGSUSED */ 4264 void 4265 vsd_defaultdestructor(void *value) 4266 {} 4267 4268 /* 4269 * Create a key (index into per vnode array) 4270 * Locks out vsd_create, vsd_destroy, and vsd_free 4271 * May allocate memory with lock held 4272 */ 4273 void 4274 vsd_create(uint_t *keyp, void (*destructor)(void *)) 4275 { 4276 int i; 4277 uint_t nkeys; 4278 4279 /* 4280 * if key is allocated, do nothing 4281 */ 4282 mutex_enter(&vsd_lock); 4283 if (*keyp) { 4284 mutex_exit(&vsd_lock); 4285 return; 4286 } 4287 /* 4288 * find an unused key 4289 */ 4290 if (destructor == NULL) 4291 destructor = vsd_defaultdestructor; 4292 4293 for (i = 0; i < vsd_nkeys; ++i) 4294 if (vsd_destructor[i] == NULL) 4295 break; 4296 4297 /* 4298 * if no unused keys, increase the size of the destructor array 4299 */ 4300 if (i == vsd_nkeys) { 4301 if ((nkeys = (vsd_nkeys << 1)) == 0) 4302 nkeys = 1; 4303 vsd_destructor = 4304 (void (**)(void *))vsd_realloc((void *)vsd_destructor, 4305 (size_t)(vsd_nkeys * sizeof (void (*)(void *))), 4306 (size_t)(nkeys * sizeof (void (*)(void *)))); 4307 vsd_nkeys = nkeys; 4308 } 4309 4310 /* 4311 * allocate the next available unused key 4312 */ 4313 vsd_destructor[i] = destructor; 4314 *keyp = i + 1; 4315 4316 /* create vsd_list, if it doesn't exist */ 4317 if (vsd_list == NULL) { 4318 vsd_list = kmem_alloc(sizeof (list_t), KM_SLEEP); 4319 list_create(vsd_list, sizeof (struct vsd_node), 4320 offsetof(struct vsd_node, vs_nodes)); 4321 } 4322 4323 mutex_exit(&vsd_lock); 4324 } 4325 4326 /* 4327 * Destroy a key 4328 * 4329 * Assumes that the caller is preventing vsd_set and vsd_get 4330 * Locks out vsd_create, vsd_destroy, and vsd_free 4331 * May free memory with lock held 4332 */ 4333 void 4334 vsd_destroy(uint_t *keyp) 4335 { 4336 uint_t key; 4337 struct vsd_node *vsd; 4338 4339 /* 4340 * protect the key namespace and our destructor lists 4341 */ 4342 mutex_enter(&vsd_lock); 4343 key = *keyp; 4344 *keyp = 0; 4345 4346 ASSERT(key <= vsd_nkeys); 4347 4348 /* 4349 * if the key is valid 4350 */ 4351 if (key != 0) { 4352 uint_t k = key - 1; 4353 /* 4354 * for every vnode with VSD, call key's destructor 4355 */ 4356 for (vsd = list_head(vsd_list); vsd != NULL; 4357 vsd = list_next(vsd_list, vsd)) { 4358 /* 4359 * no VSD for key in this vnode 4360 */ 4361 if (key > vsd->vs_nkeys) 4362 continue; 4363 /* 4364 * call destructor for key 4365 */ 4366 if (vsd->vs_value[k] && vsd_destructor[k]) 4367 (*vsd_destructor[k])(vsd->vs_value[k]); 4368 /* 4369 * reset value for key 4370 */ 4371 vsd->vs_value[k] = NULL; 4372 } 4373 /* 4374 * actually free the key (NULL destructor == unused) 4375 */ 4376 vsd_destructor[k] = NULL; 4377 } 4378 4379 mutex_exit(&vsd_lock); 4380 } 4381 4382 /* 4383 * Quickly return the per vnode value that was stored with the specified key 4384 * Assumes the caller is protecting key from vsd_create and vsd_destroy 4385 * Assumes the caller is holding v_vsd_lock to protect the vsd. 4386 */ 4387 void * 4388 vsd_get(vnode_t *vp, uint_t key) 4389 { 4390 struct vsd_node *vsd; 4391 4392 ASSERT(vp != NULL); 4393 ASSERT(mutex_owned(&vp->v_vsd_lock)); 4394 4395 vsd = vp->v_vsd; 4396 4397 if (key && vsd != NULL && key <= vsd->vs_nkeys) 4398 return (vsd->vs_value[key - 1]); 4399 return (NULL); 4400 } 4401 4402 /* 4403 * Set a per vnode value indexed with the specified key 4404 * Assumes the caller is holding v_vsd_lock to protect the vsd. 4405 */ 4406 int 4407 vsd_set(vnode_t *vp, uint_t key, void *value) 4408 { 4409 struct vsd_node *vsd; 4410 4411 ASSERT(vp != NULL); 4412 ASSERT(mutex_owned(&vp->v_vsd_lock)); 4413 4414 if (key == 0) 4415 return (EINVAL); 4416 4417 vsd = vp->v_vsd; 4418 if (vsd == NULL) 4419 vsd = vp->v_vsd = kmem_zalloc(sizeof (*vsd), KM_SLEEP); 4420 4421 /* 4422 * If the vsd was just allocated, vs_nkeys will be 0, so the following 4423 * code won't happen and we will continue down and allocate space for 4424 * the vs_value array. 4425 * If the caller is replacing one value with another, then it is up 4426 * to the caller to free/rele/destroy the previous value (if needed). 4427 */ 4428 if (key <= vsd->vs_nkeys) { 4429 vsd->vs_value[key - 1] = value; 4430 return (0); 4431 } 4432 4433 ASSERT(key <= vsd_nkeys); 4434 4435 if (vsd->vs_nkeys == 0) { 4436 mutex_enter(&vsd_lock); /* lock out vsd_destroy() */ 4437 /* 4438 * Link onto list of all VSD nodes. 4439 */ 4440 list_insert_head(vsd_list, vsd); 4441 mutex_exit(&vsd_lock); 4442 } 4443 4444 /* 4445 * Allocate vnode local storage and set the value for key 4446 */ 4447 vsd->vs_value = vsd_realloc(vsd->vs_value, 4448 vsd->vs_nkeys * sizeof (void *), 4449 key * sizeof (void *)); 4450 vsd->vs_nkeys = key; 4451 vsd->vs_value[key - 1] = value; 4452 4453 return (0); 4454 } 4455 4456 /* 4457 * Called from vn_free() to run the destructor function for each vsd 4458 * Locks out vsd_create and vsd_destroy 4459 * Assumes that the destructor *DOES NOT* use vsd 4460 */ 4461 void 4462 vsd_free(vnode_t *vp) 4463 { 4464 int i; 4465 struct vsd_node *vsd = vp->v_vsd; 4466 4467 if (vsd == NULL) 4468 return; 4469 4470 if (vsd->vs_nkeys == 0) { 4471 kmem_free(vsd, sizeof (*vsd)); 4472 vp->v_vsd = NULL; 4473 return; 4474 } 4475 4476 /* 4477 * lock out vsd_create and vsd_destroy, call 4478 * the destructor, and mark the value as destroyed. 4479 */ 4480 mutex_enter(&vsd_lock); 4481 4482 for (i = 0; i < vsd->vs_nkeys; i++) { 4483 if (vsd->vs_value[i] && vsd_destructor[i]) 4484 (*vsd_destructor[i])(vsd->vs_value[i]); 4485 vsd->vs_value[i] = NULL; 4486 } 4487 4488 /* 4489 * remove from linked list of VSD nodes 4490 */ 4491 list_remove(vsd_list, vsd); 4492 4493 mutex_exit(&vsd_lock); 4494 4495 /* 4496 * free up the VSD 4497 */ 4498 kmem_free(vsd->vs_value, vsd->vs_nkeys * sizeof (void *)); 4499 kmem_free(vsd, sizeof (struct vsd_node)); 4500 vp->v_vsd = NULL; 4501 } 4502 4503 /* 4504 * realloc 4505 */ 4506 static void * 4507 vsd_realloc(void *old, size_t osize, size_t nsize) 4508 { 4509 void *new; 4510 4511 new = kmem_zalloc(nsize, KM_SLEEP); 4512 if (old) { 4513 bcopy(old, new, osize); 4514 kmem_free(old, osize); 4515 } 4516 return (new); 4517 } 4518 4519 /* 4520 * Setup the extensible system attribute for creating a reparse point. 4521 * The symlink data 'target' is validated for proper format of a reparse 4522 * string and a check also made to make sure the symlink data does not 4523 * point to an existing file. 4524 * 4525 * return 0 if ok else -1. 4526 */ 4527 static int 4528 fs_reparse_mark(char *target, vattr_t *vap, xvattr_t *xvattr) 4529 { 4530 xoptattr_t *xoap; 4531 4532 if ((!target) || (!vap) || (!xvattr)) 4533 return (-1); 4534 4535 /* validate reparse string */ 4536 if (reparse_validate((const char *)target)) 4537 return (-1); 4538 4539 xva_init(xvattr); 4540 xvattr->xva_vattr = *vap; 4541 xvattr->xva_vattr.va_mask |= AT_XVATTR; 4542 xoap = xva_getxoptattr(xvattr); 4543 ASSERT(xoap); 4544 XVA_SET_REQ(xvattr, XAT_REPARSE); 4545 xoap->xoa_reparse = 1; 4546 4547 return (0); 4548 } 4549 4550 /* 4551 * Function to check whether a symlink is a reparse point. 4552 * Return B_TRUE if it is a reparse point, else return B_FALSE 4553 */ 4554 boolean_t 4555 vn_is_reparse(vnode_t *vp, cred_t *cr, caller_context_t *ct) 4556 { 4557 xvattr_t xvattr; 4558 xoptattr_t *xoap; 4559 4560 if ((vp->v_type != VLNK) || 4561 !(vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR))) 4562 return (B_FALSE); 4563 4564 xva_init(&xvattr); 4565 xoap = xva_getxoptattr(&xvattr); 4566 ASSERT(xoap); 4567 XVA_SET_REQ(&xvattr, XAT_REPARSE); 4568 4569 if (VOP_GETATTR(vp, &xvattr.xva_vattr, 0, cr, ct)) 4570 return (B_FALSE); 4571 4572 if ((!(xvattr.xva_vattr.va_mask & AT_XVATTR)) || 4573 (!(XVA_ISSET_RTN(&xvattr, XAT_REPARSE)))) 4574 return (B_FALSE); 4575 4576 return (xoap->xoa_reparse ? B_TRUE : B_FALSE); 4577 } 4578