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