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 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 25 #include <sys/param.h> 26 #include <sys/isa_defs.h> 27 #include <sys/types.h> 28 #include <sys/sysmacros.h> 29 #include <sys/cred.h> 30 #include <sys/systm.h> 31 #include <sys/errno.h> 32 #include <sys/fcntl.h> 33 #include <sys/pathname.h> 34 #include <sys/stat.h> 35 #include <sys/vfs.h> 36 #include <sys/acl.h> 37 #include <sys/file.h> 38 #include <sys/sunddi.h> 39 #include <sys/debug.h> 40 #include <sys/cmn_err.h> 41 #include <sys/vnode.h> 42 #include <sys/mode.h> 43 #include <sys/nvpair.h> 44 #include <sys/attr.h> 45 #include <sys/gfs.h> 46 #include <sys/mutex.h> 47 #include <fs/fs_subr.h> 48 #include <sys/kidmap.h> 49 50 typedef struct { 51 gfs_file_t xattr_gfs_private; 52 xattr_view_t xattr_view; 53 } xattr_file_t; 54 55 typedef struct { 56 gfs_dir_t xattr_gfs_private; 57 vnode_t *xattr_realvp; /* Only used for VOP_REALVP */ 58 } xattr_dir_t; 59 60 /* 61 * xattr_realvp is only used for VOP_REALVP, this is so we don't 62 * keep an unnecessary hold on the *real* xattr dir unless we have 63 * no other choice. 64 */ 65 66 /* ARGSUSED */ 67 static int 68 xattr_file_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct) 69 { 70 xattr_file_t *np = (*vpp)->v_data; 71 72 if ((np->xattr_view == XATTR_VIEW_READONLY) && (flags & FWRITE)) 73 return (EACCES); 74 75 return (0); 76 } 77 78 /* ARGSUSED */ 79 static int 80 xattr_file_access(vnode_t *vp, int mode, int flags, cred_t *cr, 81 caller_context_t *ct) 82 { 83 xattr_file_t *np = vp->v_data; 84 85 if ((np->xattr_view == XATTR_VIEW_READONLY) && (mode & VWRITE)) 86 return (EACCES); 87 88 return (0); 89 } 90 91 /* ARGSUSED */ 92 static int 93 xattr_file_close(vnode_t *vp, int flags, int count, offset_t off, 94 cred_t *cr, caller_context_t *ct) 95 { 96 cleanlocks(vp, ddi_get_pid(), 0); 97 cleanshares(vp, ddi_get_pid()); 98 return (0); 99 } 100 101 static int 102 xattr_common_fid(vnode_t *vp, fid_t *fidp, caller_context_t *ct) 103 { 104 xattr_fid_t *xfidp; 105 vnode_t *pvp, *savevp; 106 int error; 107 uint16_t orig_len; 108 109 if (fidp->fid_len < XATTR_FIDSZ) { 110 fidp->fid_len = XATTR_FIDSZ; 111 return (ENOSPC); 112 } 113 114 savevp = pvp = gfs_file_parent(vp); 115 mutex_enter(&savevp->v_lock); 116 if (pvp->v_flag & V_XATTRDIR) { 117 pvp = gfs_file_parent(pvp); 118 } 119 mutex_exit(&savevp->v_lock); 120 121 xfidp = (xattr_fid_t *)fidp; 122 orig_len = fidp->fid_len; 123 fidp->fid_len = sizeof (xfidp->parent_fid); 124 125 error = VOP_FID(pvp, fidp, ct); 126 if (error) { 127 fidp->fid_len = orig_len; 128 return (error); 129 } 130 131 xfidp->parent_len = fidp->fid_len; 132 fidp->fid_len = XATTR_FIDSZ; 133 xfidp->dir_offset = gfs_file_inode(vp); 134 135 return (0); 136 } 137 138 /* ARGSUSED */ 139 static int 140 xattr_fill_nvlist(vnode_t *vp, xattr_view_t xattr_view, nvlist_t *nvlp, 141 cred_t *cr, caller_context_t *ct) 142 { 143 int error; 144 f_attr_t attr; 145 uint64_t fsid; 146 xvattr_t xvattr; 147 xoptattr_t *xoap; /* Pointer to optional attributes */ 148 vnode_t *ppvp; 149 const char *domain; 150 uint32_t rid; 151 152 xva_init(&xvattr); 153 154 if ((xoap = xva_getxoptattr(&xvattr)) == NULL) 155 return (EINVAL); 156 157 /* 158 * For detecting ephemeral uid/gid 159 */ 160 xvattr.xva_vattr.va_mask |= (AT_UID|AT_GID); 161 162 /* 163 * We need to access the real fs object. 164 * vp points to a GFS file; ppvp points to the real object. 165 */ 166 ppvp = gfs_file_parent(gfs_file_parent(vp)); 167 168 /* 169 * Iterate through the attrs associated with this view 170 */ 171 172 for (attr = 0; attr < F_ATTR_ALL; attr++) { 173 if (xattr_view != attr_to_xattr_view(attr)) { 174 continue; 175 } 176 177 switch (attr) { 178 case F_SYSTEM: 179 XVA_SET_REQ(&xvattr, XAT_SYSTEM); 180 break; 181 case F_READONLY: 182 XVA_SET_REQ(&xvattr, XAT_READONLY); 183 break; 184 case F_HIDDEN: 185 XVA_SET_REQ(&xvattr, XAT_HIDDEN); 186 break; 187 case F_ARCHIVE: 188 XVA_SET_REQ(&xvattr, XAT_ARCHIVE); 189 break; 190 case F_IMMUTABLE: 191 XVA_SET_REQ(&xvattr, XAT_IMMUTABLE); 192 break; 193 case F_APPENDONLY: 194 XVA_SET_REQ(&xvattr, XAT_APPENDONLY); 195 break; 196 case F_NOUNLINK: 197 XVA_SET_REQ(&xvattr, XAT_NOUNLINK); 198 break; 199 case F_OPAQUE: 200 XVA_SET_REQ(&xvattr, XAT_OPAQUE); 201 break; 202 case F_NODUMP: 203 XVA_SET_REQ(&xvattr, XAT_NODUMP); 204 break; 205 case F_AV_QUARANTINED: 206 XVA_SET_REQ(&xvattr, XAT_AV_QUARANTINED); 207 break; 208 case F_AV_MODIFIED: 209 XVA_SET_REQ(&xvattr, XAT_AV_MODIFIED); 210 break; 211 case F_AV_SCANSTAMP: 212 if (ppvp->v_type == VREG) 213 XVA_SET_REQ(&xvattr, XAT_AV_SCANSTAMP); 214 break; 215 case F_CRTIME: 216 XVA_SET_REQ(&xvattr, XAT_CREATETIME); 217 break; 218 case F_FSID: 219 fsid = (((uint64_t)vp->v_vfsp->vfs_fsid.val[0] << 32) | 220 (uint64_t)(vp->v_vfsp->vfs_fsid.val[1] & 221 0xffffffff)); 222 VERIFY(nvlist_add_uint64(nvlp, attr_to_name(attr), 223 fsid) == 0); 224 break; 225 case F_REPARSE: 226 XVA_SET_REQ(&xvattr, XAT_REPARSE); 227 break; 228 case F_GEN: 229 XVA_SET_REQ(&xvattr, XAT_GEN); 230 break; 231 case F_OFFLINE: 232 XVA_SET_REQ(&xvattr, XAT_OFFLINE); 233 break; 234 case F_SPARSE: 235 XVA_SET_REQ(&xvattr, XAT_SPARSE); 236 break; 237 default: 238 break; 239 } 240 } 241 242 error = VOP_GETATTR(ppvp, &xvattr.xva_vattr, 0, cr, ct); 243 if (error) 244 return (error); 245 246 /* 247 * Process all the optional attributes together here. Notice that 248 * xoap was set when the optional attribute bits were set above. 249 */ 250 if ((xvattr.xva_vattr.va_mask & AT_XVATTR) && xoap) { 251 if (XVA_ISSET_RTN(&xvattr, XAT_READONLY)) { 252 VERIFY(nvlist_add_boolean_value(nvlp, 253 attr_to_name(F_READONLY), 254 xoap->xoa_readonly) == 0); 255 } 256 if (XVA_ISSET_RTN(&xvattr, XAT_HIDDEN)) { 257 VERIFY(nvlist_add_boolean_value(nvlp, 258 attr_to_name(F_HIDDEN), 259 xoap->xoa_hidden) == 0); 260 } 261 if (XVA_ISSET_RTN(&xvattr, XAT_SYSTEM)) { 262 VERIFY(nvlist_add_boolean_value(nvlp, 263 attr_to_name(F_SYSTEM), 264 xoap->xoa_system) == 0); 265 } 266 if (XVA_ISSET_RTN(&xvattr, XAT_ARCHIVE)) { 267 VERIFY(nvlist_add_boolean_value(nvlp, 268 attr_to_name(F_ARCHIVE), 269 xoap->xoa_archive) == 0); 270 } 271 if (XVA_ISSET_RTN(&xvattr, XAT_IMMUTABLE)) { 272 VERIFY(nvlist_add_boolean_value(nvlp, 273 attr_to_name(F_IMMUTABLE), 274 xoap->xoa_immutable) == 0); 275 } 276 if (XVA_ISSET_RTN(&xvattr, XAT_NOUNLINK)) { 277 VERIFY(nvlist_add_boolean_value(nvlp, 278 attr_to_name(F_NOUNLINK), 279 xoap->xoa_nounlink) == 0); 280 } 281 if (XVA_ISSET_RTN(&xvattr, XAT_APPENDONLY)) { 282 VERIFY(nvlist_add_boolean_value(nvlp, 283 attr_to_name(F_APPENDONLY), 284 xoap->xoa_appendonly) == 0); 285 } 286 if (XVA_ISSET_RTN(&xvattr, XAT_NODUMP)) { 287 VERIFY(nvlist_add_boolean_value(nvlp, 288 attr_to_name(F_NODUMP), 289 xoap->xoa_nodump) == 0); 290 } 291 if (XVA_ISSET_RTN(&xvattr, XAT_OPAQUE)) { 292 VERIFY(nvlist_add_boolean_value(nvlp, 293 attr_to_name(F_OPAQUE), 294 xoap->xoa_opaque) == 0); 295 } 296 if (XVA_ISSET_RTN(&xvattr, XAT_AV_QUARANTINED)) { 297 VERIFY(nvlist_add_boolean_value(nvlp, 298 attr_to_name(F_AV_QUARANTINED), 299 xoap->xoa_av_quarantined) == 0); 300 } 301 if (XVA_ISSET_RTN(&xvattr, XAT_AV_MODIFIED)) { 302 VERIFY(nvlist_add_boolean_value(nvlp, 303 attr_to_name(F_AV_MODIFIED), 304 xoap->xoa_av_modified) == 0); 305 } 306 if (XVA_ISSET_RTN(&xvattr, XAT_AV_SCANSTAMP)) { 307 VERIFY(nvlist_add_uint8_array(nvlp, 308 attr_to_name(F_AV_SCANSTAMP), 309 xoap->xoa_av_scanstamp, 310 sizeof (xoap->xoa_av_scanstamp)) == 0); 311 } 312 if (XVA_ISSET_RTN(&xvattr, XAT_CREATETIME)) { 313 VERIFY(nvlist_add_uint64_array(nvlp, 314 attr_to_name(F_CRTIME), 315 (uint64_t *)&(xoap->xoa_createtime), 316 sizeof (xoap->xoa_createtime) / 317 sizeof (uint64_t)) == 0); 318 } 319 if (XVA_ISSET_RTN(&xvattr, XAT_REPARSE)) { 320 VERIFY(nvlist_add_boolean_value(nvlp, 321 attr_to_name(F_REPARSE), 322 xoap->xoa_reparse) == 0); 323 } 324 if (XVA_ISSET_RTN(&xvattr, XAT_GEN)) { 325 VERIFY(nvlist_add_uint64(nvlp, 326 attr_to_name(F_GEN), 327 xoap->xoa_generation) == 0); 328 } 329 if (XVA_ISSET_RTN(&xvattr, XAT_OFFLINE)) { 330 VERIFY(nvlist_add_boolean_value(nvlp, 331 attr_to_name(F_OFFLINE), 332 xoap->xoa_offline) == 0); 333 } 334 if (XVA_ISSET_RTN(&xvattr, XAT_SPARSE)) { 335 VERIFY(nvlist_add_boolean_value(nvlp, 336 attr_to_name(F_SPARSE), 337 xoap->xoa_sparse) == 0); 338 } 339 } 340 /* 341 * Check for optional ownersid/groupsid 342 */ 343 344 if (xvattr.xva_vattr.va_uid > MAXUID) { 345 nvlist_t *nvl_sid; 346 347 if (nvlist_alloc(&nvl_sid, NV_UNIQUE_NAME, KM_SLEEP)) 348 return (ENOMEM); 349 350 if (kidmap_getsidbyuid(crgetzone(cr), xvattr.xva_vattr.va_uid, 351 &domain, &rid) == 0) { 352 VERIFY(nvlist_add_string(nvl_sid, 353 SID_DOMAIN, domain) == 0); 354 VERIFY(nvlist_add_uint32(nvl_sid, SID_RID, rid) == 0); 355 VERIFY(nvlist_add_nvlist(nvlp, attr_to_name(F_OWNERSID), 356 nvl_sid) == 0); 357 } 358 nvlist_free(nvl_sid); 359 } 360 if (xvattr.xva_vattr.va_gid > MAXUID) { 361 nvlist_t *nvl_sid; 362 363 if (nvlist_alloc(&nvl_sid, NV_UNIQUE_NAME, KM_SLEEP)) 364 return (ENOMEM); 365 366 if (kidmap_getsidbygid(crgetzone(cr), xvattr.xva_vattr.va_gid, 367 &domain, &rid) == 0) { 368 VERIFY(nvlist_add_string(nvl_sid, 369 SID_DOMAIN, domain) == 0); 370 VERIFY(nvlist_add_uint32(nvl_sid, SID_RID, rid) == 0); 371 VERIFY(nvlist_add_nvlist(nvlp, attr_to_name(F_GROUPSID), 372 nvl_sid) == 0); 373 } 374 nvlist_free(nvl_sid); 375 } 376 377 return (0); 378 } 379 380 /* 381 * The size of a sysattr file is the size of the nvlist that will be 382 * returned by xattr_file_read(). A call to xattr_file_write() could 383 * change the size of that nvlist. That size is not stored persistently 384 * so xattr_fill_nvlist() calls VOP_GETATTR so that it can be calculated. 385 */ 386 static int 387 xattr_file_size(vnode_t *vp, xattr_view_t xattr_view, size_t *size, 388 cred_t *cr, caller_context_t *ct) 389 { 390 nvlist_t *nvl; 391 392 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) { 393 return (ENOMEM); 394 } 395 396 if (xattr_fill_nvlist(vp, xattr_view, nvl, cr, ct)) { 397 nvlist_free(nvl); 398 return (EFAULT); 399 } 400 401 VERIFY(nvlist_size(nvl, size, NV_ENCODE_XDR) == 0); 402 nvlist_free(nvl); 403 return (0); 404 } 405 406 /* ARGSUSED */ 407 static int 408 xattr_file_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 409 caller_context_t *ct) 410 { 411 xattr_file_t *np = vp->v_data; 412 timestruc_t now; 413 size_t size; 414 int error; 415 vnode_t *pvp; 416 vattr_t pvattr; 417 418 vap->va_type = VREG; 419 vap->va_mode = MAKEIMODE(vap->va_type, 420 (np->xattr_view == XATTR_VIEW_READONLY ? 0444 : 0644)); 421 vap->va_nodeid = gfs_file_inode(vp); 422 vap->va_nlink = 1; 423 pvp = gfs_file_parent(vp); 424 (void) memset(&pvattr, 0, sizeof (pvattr)); 425 pvattr.va_mask = AT_CTIME|AT_MTIME; 426 error = VOP_GETATTR(pvp, &pvattr, flags, cr, ct); 427 if (error) { 428 return (error); 429 } 430 vap->va_ctime = pvattr.va_ctime; 431 vap->va_mtime = pvattr.va_mtime; 432 gethrestime(&now); 433 vap->va_atime = now; 434 vap->va_uid = 0; 435 vap->va_gid = 0; 436 vap->va_rdev = 0; 437 vap->va_blksize = DEV_BSIZE; 438 vap->va_seq = 0; 439 vap->va_fsid = vp->v_vfsp->vfs_dev; 440 error = xattr_file_size(vp, np->xattr_view, &size, cr, ct); 441 vap->va_size = size; 442 vap->va_nblocks = howmany(vap->va_size, vap->va_blksize); 443 return (error); 444 } 445 446 /* ARGSUSED */ 447 static int 448 xattr_file_read(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 449 caller_context_t *ct) 450 { 451 xattr_file_t *np = vp->v_data; 452 xattr_view_t xattr_view = np->xattr_view; 453 char *buf; 454 size_t filesize; 455 nvlist_t *nvl; 456 int error; 457 458 /* 459 * Validate file offset and fasttrack empty reads 460 */ 461 if (uiop->uio_loffset < (offset_t)0) 462 return (EINVAL); 463 464 if (uiop->uio_resid == 0) 465 return (0); 466 467 if (nvlist_alloc(&nvl, NV_UNIQUE_NAME, KM_SLEEP)) 468 return (ENOMEM); 469 470 if (xattr_fill_nvlist(vp, xattr_view, nvl, cr, ct)) { 471 nvlist_free(nvl); 472 return (EFAULT); 473 } 474 475 VERIFY(nvlist_size(nvl, &filesize, NV_ENCODE_XDR) == 0); 476 477 if (uiop->uio_loffset >= filesize) { 478 nvlist_free(nvl); 479 return (0); 480 } 481 482 buf = kmem_alloc(filesize, KM_SLEEP); 483 VERIFY(nvlist_pack(nvl, &buf, &filesize, NV_ENCODE_XDR, 484 KM_SLEEP) == 0); 485 486 error = uiomove((caddr_t)buf, filesize, UIO_READ, uiop); 487 kmem_free(buf, filesize); 488 nvlist_free(nvl); 489 return (error); 490 } 491 492 /* ARGSUSED */ 493 static int 494 xattr_file_write(vnode_t *vp, uio_t *uiop, int ioflag, cred_t *cr, 495 caller_context_t *ct) 496 { 497 int error = 0; 498 char *buf; 499 char *domain; 500 uint32_t rid; 501 ssize_t size = uiop->uio_resid; 502 nvlist_t *nvp; 503 nvpair_t *pair = NULL; 504 vnode_t *ppvp; 505 xvattr_t xvattr; 506 xoptattr_t *xoap = NULL; /* Pointer to optional attributes */ 507 508 if (vfs_has_feature(vp->v_vfsp, VFSFT_XVATTR) == 0) 509 return (EINVAL); 510 511 /* 512 * Validate file offset and size. 513 */ 514 if (uiop->uio_loffset < (offset_t)0) 515 return (EINVAL); 516 517 if (size == 0) 518 return (EINVAL); 519 520 xva_init(&xvattr); 521 522 if ((xoap = xva_getxoptattr(&xvattr)) == NULL) { 523 return (EINVAL); 524 } 525 526 /* 527 * Copy and unpack the nvlist 528 */ 529 buf = kmem_alloc(size, KM_SLEEP); 530 if (uiomove((caddr_t)buf, size, UIO_WRITE, uiop)) { 531 return (EFAULT); 532 } 533 534 if (nvlist_unpack(buf, size, &nvp, KM_SLEEP) != 0) { 535 kmem_free(buf, size); 536 uiop->uio_resid = size; 537 return (EINVAL); 538 } 539 kmem_free(buf, size); 540 541 /* 542 * Fasttrack empty writes (nvlist with no nvpairs) 543 */ 544 if (nvlist_next_nvpair(nvp, NULL) == 0) 545 return (0); 546 547 ppvp = gfs_file_parent(gfs_file_parent(vp)); 548 549 while (pair = nvlist_next_nvpair(nvp, pair)) { 550 data_type_t type; 551 f_attr_t attr; 552 boolean_t value; 553 uint64_t *time, *times; 554 uint_t elem, nelems; 555 nvlist_t *nvp_sid; 556 uint8_t *scanstamp; 557 558 /* 559 * Validate the name and type of each attribute. 560 * Log any unknown names and continue. This will 561 * help if additional attributes are added later. 562 */ 563 type = nvpair_type(pair); 564 if ((attr = name_to_attr(nvpair_name(pair))) == F_ATTR_INVAL) { 565 cmn_err(CE_WARN, "Unknown attribute %s", 566 nvpair_name(pair)); 567 continue; 568 } 569 570 /* 571 * Verify nvlist type matches required type and view is OK 572 */ 573 574 if (type != attr_to_data_type(attr) || 575 (attr_to_xattr_view(attr) == XATTR_VIEW_READONLY)) { 576 nvlist_free(nvp); 577 return (EINVAL); 578 } 579 580 /* 581 * For OWNERSID/GROUPSID make sure the target 582 * file system support ephemeral ID's 583 */ 584 if ((attr == F_OWNERSID || attr == F_GROUPSID) && 585 (!(vp->v_vfsp->vfs_flag & VFS_XID))) { 586 nvlist_free(nvp); 587 return (EINVAL); 588 } 589 590 /* 591 * Retrieve data from nvpair 592 */ 593 switch (type) { 594 case DATA_TYPE_BOOLEAN_VALUE: 595 if (nvpair_value_boolean_value(pair, &value)) { 596 nvlist_free(nvp); 597 return (EINVAL); 598 } 599 break; 600 case DATA_TYPE_UINT64_ARRAY: 601 if (nvpair_value_uint64_array(pair, ×, &nelems)) { 602 nvlist_free(nvp); 603 return (EINVAL); 604 } 605 break; 606 case DATA_TYPE_NVLIST: 607 if (nvpair_value_nvlist(pair, &nvp_sid)) { 608 nvlist_free(nvp); 609 return (EINVAL); 610 } 611 break; 612 case DATA_TYPE_UINT8_ARRAY: 613 if (nvpair_value_uint8_array(pair, 614 &scanstamp, &nelems)) { 615 nvlist_free(nvp); 616 return (EINVAL); 617 } 618 break; 619 default: 620 nvlist_free(nvp); 621 return (EINVAL); 622 } 623 624 switch (attr) { 625 /* 626 * If we have several similar optional attributes to 627 * process then we should do it all together here so that 628 * xoap and the requested bitmap can be set in one place. 629 */ 630 case F_READONLY: 631 XVA_SET_REQ(&xvattr, XAT_READONLY); 632 xoap->xoa_readonly = value; 633 break; 634 case F_HIDDEN: 635 XVA_SET_REQ(&xvattr, XAT_HIDDEN); 636 xoap->xoa_hidden = value; 637 break; 638 case F_SYSTEM: 639 XVA_SET_REQ(&xvattr, XAT_SYSTEM); 640 xoap->xoa_system = value; 641 break; 642 case F_ARCHIVE: 643 XVA_SET_REQ(&xvattr, XAT_ARCHIVE); 644 xoap->xoa_archive = value; 645 break; 646 case F_IMMUTABLE: 647 XVA_SET_REQ(&xvattr, XAT_IMMUTABLE); 648 xoap->xoa_immutable = value; 649 break; 650 case F_NOUNLINK: 651 XVA_SET_REQ(&xvattr, XAT_NOUNLINK); 652 xoap->xoa_nounlink = value; 653 break; 654 case F_APPENDONLY: 655 XVA_SET_REQ(&xvattr, XAT_APPENDONLY); 656 xoap->xoa_appendonly = value; 657 break; 658 case F_NODUMP: 659 XVA_SET_REQ(&xvattr, XAT_NODUMP); 660 xoap->xoa_nodump = value; 661 break; 662 case F_AV_QUARANTINED: 663 XVA_SET_REQ(&xvattr, XAT_AV_QUARANTINED); 664 xoap->xoa_av_quarantined = value; 665 break; 666 case F_AV_MODIFIED: 667 XVA_SET_REQ(&xvattr, XAT_AV_MODIFIED); 668 xoap->xoa_av_modified = value; 669 break; 670 case F_CRTIME: 671 XVA_SET_REQ(&xvattr, XAT_CREATETIME); 672 time = (uint64_t *)&(xoap->xoa_createtime); 673 for (elem = 0; elem < nelems; elem++) 674 *time++ = times[elem]; 675 break; 676 case F_OWNERSID: 677 case F_GROUPSID: 678 if (nvlist_lookup_string(nvp_sid, SID_DOMAIN, 679 &domain) || nvlist_lookup_uint32(nvp_sid, SID_RID, 680 &rid)) { 681 nvlist_free(nvp); 682 return (EINVAL); 683 } 684 685 /* 686 * Now map domain+rid to ephemeral id's 687 * 688 * If mapping fails, then the uid/gid will 689 * be set to UID_NOBODY by Winchester. 690 */ 691 692 if (attr == F_OWNERSID) { 693 (void) kidmap_getuidbysid(crgetzone(cr), domain, 694 rid, &xvattr.xva_vattr.va_uid); 695 xvattr.xva_vattr.va_mask |= AT_UID; 696 } else { 697 (void) kidmap_getgidbysid(crgetzone(cr), domain, 698 rid, &xvattr.xva_vattr.va_gid); 699 xvattr.xva_vattr.va_mask |= AT_GID; 700 } 701 break; 702 case F_AV_SCANSTAMP: 703 if (ppvp->v_type == VREG) { 704 XVA_SET_REQ(&xvattr, XAT_AV_SCANSTAMP); 705 (void) memcpy(xoap->xoa_av_scanstamp, 706 scanstamp, nelems); 707 } else { 708 nvlist_free(nvp); 709 return (EINVAL); 710 } 711 break; 712 case F_REPARSE: 713 XVA_SET_REQ(&xvattr, XAT_REPARSE); 714 xoap->xoa_reparse = value; 715 break; 716 case F_OFFLINE: 717 XVA_SET_REQ(&xvattr, XAT_OFFLINE); 718 xoap->xoa_offline = value; 719 break; 720 case F_SPARSE: 721 XVA_SET_REQ(&xvattr, XAT_SPARSE); 722 xoap->xoa_sparse = value; 723 break; 724 default: 725 break; 726 } 727 } 728 729 ppvp = gfs_file_parent(gfs_file_parent(vp)); 730 error = VOP_SETATTR(ppvp, &xvattr.xva_vattr, 0, cr, ct); 731 if (error) 732 uiop->uio_resid = size; 733 734 nvlist_free(nvp); 735 return (error); 736 } 737 738 static int 739 xattr_file_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr, 740 caller_context_t *ct) 741 { 742 switch (cmd) { 743 case _PC_XATTR_EXISTS: 744 case _PC_SATTR_ENABLED: 745 case _PC_SATTR_EXISTS: 746 *valp = 0; 747 return (0); 748 default: 749 return (fs_pathconf(vp, cmd, valp, cr, ct)); 750 } 751 } 752 753 vnodeops_t *xattr_file_ops; 754 755 static const fs_operation_def_t xattr_file_tops[] = { 756 { VOPNAME_OPEN, { .vop_open = xattr_file_open } }, 757 { VOPNAME_CLOSE, { .vop_close = xattr_file_close } }, 758 { VOPNAME_READ, { .vop_read = xattr_file_read } }, 759 { VOPNAME_WRITE, { .vop_write = xattr_file_write } }, 760 { VOPNAME_IOCTL, { .error = fs_ioctl } }, 761 { VOPNAME_GETATTR, { .vop_getattr = xattr_file_getattr } }, 762 { VOPNAME_ACCESS, { .vop_access = xattr_file_access } }, 763 { VOPNAME_READDIR, { .error = fs_notdir } }, 764 { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 765 { VOPNAME_INACTIVE, { .vop_inactive = gfs_vop_inactive } }, 766 { VOPNAME_FID, { .vop_fid = xattr_common_fid } }, 767 { VOPNAME_PATHCONF, { .vop_pathconf = xattr_file_pathconf } }, 768 { VOPNAME_PUTPAGE, { .error = fs_putpage } }, 769 { VOPNAME_FSYNC, { .error = fs_fsync } }, 770 { NULL } 771 }; 772 773 vnode_t * 774 xattr_mkfile(vnode_t *pvp, xattr_view_t xattr_view) 775 { 776 vnode_t *vp; 777 xattr_file_t *np; 778 779 vp = gfs_file_create(sizeof (xattr_file_t), pvp, xattr_file_ops); 780 np = vp->v_data; 781 np->xattr_view = xattr_view; 782 vp->v_flag |= V_SYSATTR; 783 return (vp); 784 } 785 786 vnode_t * 787 xattr_mkfile_ro(vnode_t *pvp) 788 { 789 return (xattr_mkfile(pvp, XATTR_VIEW_READONLY)); 790 } 791 792 vnode_t * 793 xattr_mkfile_rw(vnode_t *pvp) 794 { 795 return (xattr_mkfile(pvp, XATTR_VIEW_READWRITE)); 796 } 797 798 vnodeops_t *xattr_dir_ops; 799 800 static gfs_dirent_t xattr_dirents[] = { 801 { VIEW_READONLY, xattr_mkfile_ro, GFS_CACHE_VNODE, }, 802 { VIEW_READWRITE, xattr_mkfile_rw, GFS_CACHE_VNODE, }, 803 { NULL }, 804 }; 805 806 #define XATTRDIR_NENTS ((sizeof (xattr_dirents) / sizeof (gfs_dirent_t)) - 1) 807 808 static int 809 is_sattr_name(char *s) 810 { 811 int i; 812 813 for (i = 0; i < XATTRDIR_NENTS; ++i) { 814 if (strcmp(s, xattr_dirents[i].gfse_name) == 0) { 815 return (1); 816 } 817 } 818 return (0); 819 } 820 821 /* 822 * Given the name of an extended attribute file, determine if there is a 823 * normalization conflict with a sysattr view name. 824 */ 825 int 826 xattr_sysattr_casechk(char *s) 827 { 828 int i; 829 830 for (i = 0; i < XATTRDIR_NENTS; ++i) { 831 if (strcasecmp(s, xattr_dirents[i].gfse_name) == 0) 832 return (1); 833 } 834 return (0); 835 } 836 837 static int 838 xattr_copy(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, 839 cred_t *cr, caller_context_t *ct) 840 { 841 xvattr_t xvattr; 842 vnode_t *pdvp; 843 int error; 844 845 /* 846 * Only copy system attrs if the views are the same 847 */ 848 if (strcmp(snm, tnm) != 0) 849 return (EINVAL); 850 851 xva_init(&xvattr); 852 853 XVA_SET_REQ(&xvattr, XAT_SYSTEM); 854 XVA_SET_REQ(&xvattr, XAT_READONLY); 855 XVA_SET_REQ(&xvattr, XAT_HIDDEN); 856 XVA_SET_REQ(&xvattr, XAT_ARCHIVE); 857 XVA_SET_REQ(&xvattr, XAT_APPENDONLY); 858 XVA_SET_REQ(&xvattr, XAT_NOUNLINK); 859 XVA_SET_REQ(&xvattr, XAT_IMMUTABLE); 860 XVA_SET_REQ(&xvattr, XAT_NODUMP); 861 XVA_SET_REQ(&xvattr, XAT_AV_MODIFIED); 862 XVA_SET_REQ(&xvattr, XAT_AV_QUARANTINED); 863 XVA_SET_REQ(&xvattr, XAT_CREATETIME); 864 XVA_SET_REQ(&xvattr, XAT_REPARSE); 865 XVA_SET_REQ(&xvattr, XAT_OFFLINE); 866 XVA_SET_REQ(&xvattr, XAT_SPARSE); 867 868 pdvp = gfs_file_parent(sdvp); 869 error = VOP_GETATTR(pdvp, &xvattr.xva_vattr, 0, cr, ct); 870 if (error) 871 return (error); 872 873 pdvp = gfs_file_parent(tdvp); 874 error = VOP_SETATTR(pdvp, &xvattr.xva_vattr, 0, cr, ct); 875 return (error); 876 } 877 878 static int 879 xattr_dir_realdir(vnode_t *dvp, vnode_t **realdvp, int lookup_flags, 880 cred_t *cr, caller_context_t *ct) 881 { 882 vnode_t *pvp; 883 int error; 884 struct pathname pn; 885 char *startnm = ""; 886 887 *realdvp = NULL; 888 889 pvp = gfs_file_parent(dvp); 890 891 error = pn_get(startnm, UIO_SYSSPACE, &pn); 892 if (error) { 893 VN_RELE(pvp); 894 return (error); 895 } 896 897 /* 898 * Set the LOOKUP_HAVE_SYSATTR_DIR flag so that we don't get into an 899 * infinite loop with fop_lookup calling back to xattr_dir_lookup. 900 */ 901 lookup_flags |= LOOKUP_HAVE_SYSATTR_DIR; 902 error = VOP_LOOKUP(pvp, startnm, realdvp, &pn, lookup_flags, 903 rootvp, cr, ct, NULL, NULL); 904 pn_free(&pn); 905 906 return (error); 907 } 908 909 /* ARGSUSED */ 910 static int 911 xattr_dir_open(vnode_t **vpp, int flags, cred_t *cr, caller_context_t *ct) 912 { 913 if (flags & FWRITE) { 914 return (EACCES); 915 } 916 917 return (0); 918 } 919 920 /* ARGSUSED */ 921 static int 922 xattr_dir_close(vnode_t *vpp, int flags, int count, offset_t off, cred_t *cr, 923 caller_context_t *ct) 924 { 925 return (0); 926 } 927 928 /* 929 * Retrieve the attributes on an xattr directory. If there is a "real" 930 * xattr directory, use that. Otherwise, get the attributes (represented 931 * by PARENT_ATTRMASK) from the "parent" node and fill in the rest. Note 932 * that VOP_GETATTR() could turn off bits in the va_mask. 933 */ 934 935 #define PARENT_ATTRMASK (AT_UID|AT_GID|AT_RDEV|AT_CTIME|AT_MTIME) 936 937 /* ARGSUSED */ 938 static int 939 xattr_dir_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 940 caller_context_t *ct) 941 { 942 timestruc_t now; 943 vnode_t *pvp; 944 int error; 945 946 error = xattr_dir_realdir(vp, &pvp, LOOKUP_XATTR, cr, ct); 947 if (error == 0) { 948 error = VOP_GETATTR(pvp, vap, 0, cr, ct); 949 VN_RELE(pvp); 950 if (error) { 951 return (error); 952 } 953 vap->va_nlink += XATTRDIR_NENTS; 954 vap->va_size += XATTRDIR_NENTS; 955 return (0); 956 } 957 958 /* 959 * There is no real xattr directory. Cobble together 960 * an entry using info from the parent object (if needed) 961 * plus information common to all xattrs. 962 */ 963 if (vap->va_mask & PARENT_ATTRMASK) { 964 vattr_t pvattr; 965 uint_t off_bits; 966 967 pvp = gfs_file_parent(vp); 968 (void) memset(&pvattr, 0, sizeof (pvattr)); 969 pvattr.va_mask = PARENT_ATTRMASK; 970 error = VOP_GETATTR(pvp, &pvattr, 0, cr, ct); 971 if (error) { 972 return (error); 973 } 974 975 /* 976 * VOP_GETATTR() might have turned off some bits in 977 * pvattr.va_mask. This means that the underlying 978 * file system couldn't process those attributes. 979 * We need to make sure those bits get turned off 980 * in the vattr_t structure that gets passed back 981 * to the caller. Figure out which bits were turned 982 * off (if any) then set pvattr.va_mask before it 983 * gets copied to the vattr_t that the caller sees. 984 */ 985 off_bits = (pvattr.va_mask ^ PARENT_ATTRMASK) & PARENT_ATTRMASK; 986 pvattr.va_mask = vap->va_mask & ~off_bits; 987 *vap = pvattr; 988 } 989 990 vap->va_type = VDIR; 991 vap->va_mode = MAKEIMODE(vap->va_type, S_ISVTX | 0777); 992 vap->va_fsid = vp->v_vfsp->vfs_dev; 993 vap->va_nodeid = gfs_file_inode(vp); 994 vap->va_nlink = XATTRDIR_NENTS+2; 995 vap->va_size = vap->va_nlink; 996 gethrestime(&now); 997 vap->va_atime = now; 998 vap->va_blksize = 0; 999 vap->va_nblocks = 0; 1000 vap->va_seq = 0; 1001 return (0); 1002 } 1003 1004 static int 1005 xattr_dir_setattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cr, 1006 caller_context_t *ct) 1007 { 1008 vnode_t *realvp; 1009 int error; 1010 1011 /* 1012 * If there is a real xattr directory, do the setattr there. 1013 * Otherwise, just return success. The GFS directory is transient, 1014 * and any setattr changes can disappear anyway. 1015 */ 1016 error = xattr_dir_realdir(vp, &realvp, LOOKUP_XATTR, cr, ct); 1017 if (error == 0) { 1018 error = VOP_SETATTR(realvp, vap, flags, cr, ct); 1019 VN_RELE(realvp); 1020 } 1021 if (error == ENOENT) { 1022 error = 0; 1023 } 1024 return (error); 1025 } 1026 1027 /* ARGSUSED */ 1028 static int 1029 xattr_dir_access(vnode_t *vp, int mode, int flags, cred_t *cr, 1030 caller_context_t *ct) 1031 { 1032 int error; 1033 vnode_t *realvp = NULL; 1034 1035 if (mode & VWRITE) { 1036 return (EACCES); 1037 } 1038 1039 error = xattr_dir_realdir(vp, &realvp, LOOKUP_XATTR, cr, ct); 1040 1041 if (realvp) 1042 VN_RELE(realvp); 1043 1044 /* 1045 * No real xattr dir isn't an error 1046 * an error of EINVAL indicates attributes on attributes 1047 * are not supported. In that case just allow access to the 1048 * transient directory. 1049 */ 1050 return ((error == ENOENT || error == EINVAL) ? 0 : error); 1051 } 1052 1053 static int 1054 xattr_dir_create(vnode_t *dvp, char *name, vattr_t *vap, vcexcl_t excl, 1055 int mode, vnode_t **vpp, cred_t *cr, int flag, caller_context_t *ct, 1056 vsecattr_t *vsecp) 1057 { 1058 vnode_t *pvp; 1059 int error; 1060 1061 *vpp = NULL; 1062 1063 /* 1064 * Don't allow creation of extended attributes with sysattr names. 1065 */ 1066 if (is_sattr_name(name)) { 1067 return (gfs_dir_lookup(dvp, name, vpp, cr, 0, NULL, NULL)); 1068 } 1069 1070 error = xattr_dir_realdir(dvp, &pvp, LOOKUP_XATTR|CREATE_XATTR_DIR, 1071 cr, ct); 1072 if (error == 0) { 1073 error = VOP_CREATE(pvp, name, vap, excl, mode, vpp, cr, flag, 1074 ct, vsecp); 1075 VN_RELE(pvp); 1076 } 1077 return (error); 1078 } 1079 1080 static int 1081 xattr_dir_remove(vnode_t *dvp, char *name, cred_t *cr, caller_context_t *ct, 1082 int flags) 1083 { 1084 vnode_t *pvp; 1085 int error; 1086 1087 if (is_sattr_name(name)) { 1088 return (EACCES); 1089 } 1090 1091 error = xattr_dir_realdir(dvp, &pvp, LOOKUP_XATTR, cr, ct); 1092 if (error == 0) { 1093 error = VOP_REMOVE(pvp, name, cr, ct, flags); 1094 VN_RELE(pvp); 1095 } 1096 return (error); 1097 } 1098 1099 static int 1100 xattr_dir_link(vnode_t *tdvp, vnode_t *svp, char *name, cred_t *cr, 1101 caller_context_t *ct, int flags) 1102 { 1103 vnode_t *pvp; 1104 int error; 1105 1106 if (svp->v_flag & V_SYSATTR) { 1107 return (EINVAL); 1108 } 1109 1110 error = xattr_dir_realdir(tdvp, &pvp, LOOKUP_XATTR, cr, ct); 1111 if (error == 0) { 1112 error = VOP_LINK(pvp, svp, name, cr, ct, flags); 1113 VN_RELE(pvp); 1114 } 1115 return (error); 1116 } 1117 1118 static int 1119 xattr_dir_rename(vnode_t *sdvp, char *snm, vnode_t *tdvp, char *tnm, 1120 cred_t *cr, caller_context_t *ct, int flags) 1121 { 1122 vnode_t *spvp, *tpvp; 1123 int error; 1124 int held_tgt; 1125 1126 if (is_sattr_name(snm) || is_sattr_name(tnm)) 1127 return (xattr_copy(sdvp, snm, tdvp, tnm, cr, ct)); 1128 /* 1129 * We know that sdvp is a GFS dir, or we wouldn't be here. 1130 * Get the real unnamed directory. 1131 */ 1132 error = xattr_dir_realdir(sdvp, &spvp, LOOKUP_XATTR, cr, ct); 1133 if (error) { 1134 return (error); 1135 } 1136 1137 if (sdvp == tdvp) { 1138 /* 1139 * If the source and target are the same GFS directory, the 1140 * underlying unnamed source and target dir will be the same. 1141 */ 1142 tpvp = spvp; 1143 VN_HOLD(tpvp); 1144 held_tgt = 1; 1145 } else if (tdvp->v_flag & V_SYSATTR) { 1146 /* 1147 * If the target dir is a different GFS directory, 1148 * find its underlying unnamed dir. 1149 */ 1150 error = xattr_dir_realdir(tdvp, &tpvp, LOOKUP_XATTR, cr, ct); 1151 if (error) { 1152 VN_RELE(spvp); 1153 return (error); 1154 } 1155 held_tgt = 1; 1156 } else { 1157 /* 1158 * Target dir is outside of GFS, pass it on through. 1159 */ 1160 tpvp = tdvp; 1161 held_tgt = 0; 1162 } 1163 1164 error = VOP_RENAME(spvp, snm, tpvp, tnm, cr, ct, flags); 1165 1166 if (held_tgt) { 1167 VN_RELE(tpvp); 1168 } 1169 VN_RELE(spvp); 1170 1171 return (error); 1172 } 1173 1174 /* 1175 * readdir_xattr_casecmp: given a system attribute name, see if there 1176 * is a real xattr with the same normalized name. 1177 */ 1178 static int 1179 readdir_xattr_casecmp(vnode_t *dvp, char *nm, cred_t *cr, caller_context_t *ct, 1180 int *eflags) 1181 { 1182 int error; 1183 vnode_t *vp; 1184 struct pathname pn; 1185 1186 *eflags = 0; 1187 1188 error = pn_get(nm, UIO_SYSSPACE, &pn); 1189 if (error == 0) { 1190 error = VOP_LOOKUP(dvp, nm, &vp, &pn, 1191 FIGNORECASE, rootvp, cr, ct, NULL, NULL); 1192 if (error == 0) { 1193 *eflags = ED_CASE_CONFLICT; 1194 VN_RELE(vp); 1195 } else if (error == ENOENT) { 1196 error = 0; 1197 } 1198 pn_free(&pn); 1199 } 1200 1201 return (error); 1202 } 1203 1204 static int 1205 xattr_dir_readdir(vnode_t *dvp, uio_t *uiop, cred_t *cr, int *eofp, 1206 caller_context_t *ct, int flags) 1207 { 1208 vnode_t *pvp; 1209 int error; 1210 int local_eof; 1211 int reset_off = 0; 1212 int has_xattrs = 0; 1213 1214 if (eofp == NULL) { 1215 eofp = &local_eof; 1216 } 1217 *eofp = 0; 1218 1219 /* 1220 * See if there is a real extended attribute directory. 1221 */ 1222 error = xattr_dir_realdir(dvp, &pvp, LOOKUP_XATTR, cr, ct); 1223 if (error == 0) { 1224 has_xattrs = 1; 1225 } 1226 1227 /* 1228 * Start by reading up the static entries. 1229 */ 1230 if (uiop->uio_loffset == 0) { 1231 ino64_t pino, ino; 1232 offset_t off; 1233 gfs_dir_t *dp = dvp->v_data; 1234 gfs_readdir_state_t gstate; 1235 1236 if (has_xattrs) { 1237 /* 1238 * If there is a real xattr dir, skip . and .. 1239 * in the GFS dir. We'll pick them up below 1240 * when we call into the underlying fs. 1241 */ 1242 uiop->uio_loffset = GFS_STATIC_ENTRY_OFFSET; 1243 } 1244 error = gfs_get_parent_ino(dvp, cr, ct, &pino, &ino); 1245 if (error == 0) { 1246 error = gfs_readdir_init(&gstate, dp->gfsd_maxlen, 1, 1247 uiop, pino, ino, flags); 1248 } 1249 if (error) { 1250 if (has_xattrs) 1251 VN_RELE(pvp); 1252 return (error); 1253 } 1254 1255 while ((error = gfs_readdir_pred(&gstate, uiop, &off)) == 0 && 1256 !*eofp) { 1257 if (off >= 0 && off < dp->gfsd_nstatic) { 1258 int eflags; 1259 1260 /* 1261 * Check to see if this sysattr set name has a 1262 * case-insensitive conflict with a real xattr 1263 * name. 1264 */ 1265 eflags = 0; 1266 if ((flags & V_RDDIR_ENTFLAGS) && has_xattrs) { 1267 error = readdir_xattr_casecmp(pvp, 1268 dp->gfsd_static[off].gfse_name, 1269 cr, ct, &eflags); 1270 if (error) 1271 break; 1272 } 1273 ino = dp->gfsd_inode(dvp, off); 1274 1275 error = gfs_readdir_emit(&gstate, uiop, off, 1276 ino, dp->gfsd_static[off].gfse_name, 1277 eflags); 1278 if (error) 1279 break; 1280 } else { 1281 *eofp = 1; 1282 } 1283 } 1284 1285 error = gfs_readdir_fini(&gstate, error, eofp, *eofp); 1286 if (error) { 1287 if (has_xattrs) 1288 VN_RELE(pvp); 1289 return (error); 1290 } 1291 1292 /* 1293 * We must read all of the static entries in the first 1294 * call. Otherwise we won't know if uio_loffset in a 1295 * subsequent call refers to the static entries or to those 1296 * in an underlying fs. 1297 */ 1298 if (*eofp == 0) 1299 return (EINVAL); 1300 reset_off = 1; 1301 } 1302 1303 if (!has_xattrs) { 1304 *eofp = 1; 1305 return (0); 1306 } 1307 1308 *eofp = 0; 1309 if (reset_off) { 1310 uiop->uio_loffset = 0; 1311 } 1312 (void) VOP_RWLOCK(pvp, V_WRITELOCK_FALSE, NULL); 1313 error = VOP_READDIR(pvp, uiop, cr, eofp, ct, flags); 1314 VOP_RWUNLOCK(pvp, V_WRITELOCK_FALSE, NULL); 1315 VN_RELE(pvp); 1316 1317 return (error); 1318 } 1319 1320 /* ARGSUSED */ 1321 static void 1322 xattr_dir_inactive(vnode_t *vp, cred_t *cr, caller_context_t *ct) 1323 { 1324 gfs_file_t *fp; 1325 xattr_dir_t *xattr_dir; 1326 1327 mutex_enter(&vp->v_lock); 1328 xattr_dir = vp->v_data; 1329 if (xattr_dir->xattr_realvp) { 1330 VN_RELE(xattr_dir->xattr_realvp); 1331 xattr_dir->xattr_realvp = NULL; 1332 } 1333 mutex_exit(&vp->v_lock); 1334 fp = gfs_dir_inactive(vp); 1335 if (fp != NULL) { 1336 kmem_free(fp, fp->gfs_size); 1337 } 1338 } 1339 1340 static int 1341 xattr_dir_pathconf(vnode_t *vp, int cmd, ulong_t *valp, cred_t *cr, 1342 caller_context_t *ct) 1343 { 1344 switch (cmd) { 1345 case _PC_XATTR_EXISTS: 1346 case _PC_SATTR_ENABLED: 1347 case _PC_SATTR_EXISTS: 1348 *valp = 0; 1349 return (0); 1350 default: 1351 return (fs_pathconf(vp, cmd, valp, cr, ct)); 1352 } 1353 } 1354 1355 /* ARGSUSED */ 1356 static int 1357 xattr_dir_realvp(vnode_t *vp, vnode_t **realvp, caller_context_t *ct) 1358 { 1359 xattr_dir_t *xattr_dir; 1360 1361 mutex_enter(&vp->v_lock); 1362 xattr_dir = vp->v_data; 1363 if (xattr_dir->xattr_realvp) { 1364 *realvp = xattr_dir->xattr_realvp; 1365 mutex_exit(&vp->v_lock); 1366 return (0); 1367 } else { 1368 vnode_t *xdvp; 1369 int error; 1370 1371 mutex_exit(&vp->v_lock); 1372 if ((error = xattr_dir_realdir(vp, &xdvp, 1373 LOOKUP_XATTR, kcred, NULL)) == 0) { 1374 /* 1375 * verify we aren't racing with another thread 1376 * to find the xattr_realvp 1377 */ 1378 mutex_enter(&vp->v_lock); 1379 if (xattr_dir->xattr_realvp == NULL) { 1380 xattr_dir->xattr_realvp = xdvp; 1381 *realvp = xdvp; 1382 mutex_exit(&vp->v_lock); 1383 } else { 1384 *realvp = xattr_dir->xattr_realvp; 1385 mutex_exit(&vp->v_lock); 1386 VN_RELE(xdvp); 1387 } 1388 } 1389 return (error); 1390 } 1391 } 1392 1393 static const fs_operation_def_t xattr_dir_tops[] = { 1394 { VOPNAME_OPEN, { .vop_open = xattr_dir_open } }, 1395 { VOPNAME_CLOSE, { .vop_close = xattr_dir_close } }, 1396 { VOPNAME_IOCTL, { .error = fs_inval } }, 1397 { VOPNAME_GETATTR, { .vop_getattr = xattr_dir_getattr } }, 1398 { VOPNAME_SETATTR, { .vop_setattr = xattr_dir_setattr } }, 1399 { VOPNAME_ACCESS, { .vop_access = xattr_dir_access } }, 1400 { VOPNAME_READDIR, { .vop_readdir = xattr_dir_readdir } }, 1401 { VOPNAME_LOOKUP, { .vop_lookup = gfs_vop_lookup } }, 1402 { VOPNAME_CREATE, { .vop_create = xattr_dir_create } }, 1403 { VOPNAME_REMOVE, { .vop_remove = xattr_dir_remove } }, 1404 { VOPNAME_LINK, { .vop_link = xattr_dir_link } }, 1405 { VOPNAME_RENAME, { .vop_rename = xattr_dir_rename } }, 1406 { VOPNAME_MKDIR, { .error = fs_inval } }, 1407 { VOPNAME_SEEK, { .vop_seek = fs_seek } }, 1408 { VOPNAME_INACTIVE, { .vop_inactive = xattr_dir_inactive } }, 1409 { VOPNAME_FID, { .vop_fid = xattr_common_fid } }, 1410 { VOPNAME_PATHCONF, { .vop_pathconf = xattr_dir_pathconf } }, 1411 { VOPNAME_REALVP, { .vop_realvp = xattr_dir_realvp } }, 1412 { NULL, NULL } 1413 }; 1414 1415 static gfs_opsvec_t xattr_opsvec[] = { 1416 { "xattr dir", xattr_dir_tops, &xattr_dir_ops }, 1417 { "system attributes", xattr_file_tops, &xattr_file_ops }, 1418 { NULL, NULL, NULL } 1419 }; 1420 1421 static int 1422 xattr_lookup_cb(vnode_t *vp, const char *nm, vnode_t **vpp, ino64_t *inop, 1423 cred_t *cr, int flags, int *deflags, pathname_t *rpnp) 1424 { 1425 vnode_t *pvp; 1426 struct pathname pn; 1427 int error; 1428 1429 *vpp = NULL; 1430 *inop = 0; 1431 1432 error = xattr_dir_realdir(vp, &pvp, LOOKUP_XATTR|CREATE_XATTR_DIR, 1433 cr, NULL); 1434 1435 /* 1436 * Return ENOENT for EACCES requests during lookup. Once an 1437 * attribute create is attempted EACCES will be returned. 1438 */ 1439 if (error) { 1440 if (error == EACCES) 1441 return (ENOENT); 1442 return (error); 1443 } 1444 1445 error = pn_get((char *)nm, UIO_SYSSPACE, &pn); 1446 if (error == 0) { 1447 error = VOP_LOOKUP(pvp, (char *)nm, vpp, &pn, flags, rootvp, 1448 cr, NULL, deflags, rpnp); 1449 pn_free(&pn); 1450 } 1451 VN_RELE(pvp); 1452 1453 return (error); 1454 } 1455 1456 /* ARGSUSED */ 1457 static ino64_t 1458 xattrdir_do_ino(vnode_t *vp, int index) 1459 { 1460 /* 1461 * We use index 0 for the directory fid. Start 1462 * the file numbering at 1. 1463 */ 1464 return ((ino64_t)index+1); 1465 } 1466 1467 void 1468 xattr_init(void) 1469 { 1470 VERIFY(gfs_make_opsvec(xattr_opsvec) == 0); 1471 } 1472 1473 int 1474 xattr_dir_lookup(vnode_t *dvp, vnode_t **vpp, int flags, cred_t *cr) 1475 { 1476 int error = 0; 1477 1478 *vpp = NULL; 1479 1480 if (dvp->v_type != VDIR && dvp->v_type != VREG) 1481 return (EINVAL); 1482 1483 mutex_enter(&dvp->v_lock); 1484 1485 /* 1486 * If we're already in sysattr space, don't allow creation 1487 * of another level of sysattrs. 1488 */ 1489 if (dvp->v_flag & V_SYSATTR) { 1490 mutex_exit(&dvp->v_lock); 1491 return (EINVAL); 1492 } 1493 1494 if (dvp->v_xattrdir != NULL) { 1495 *vpp = dvp->v_xattrdir; 1496 VN_HOLD(*vpp); 1497 } else { 1498 ulong_t val; 1499 int xattrs_allowed = dvp->v_vfsp->vfs_flag & VFS_XATTR; 1500 int sysattrs_allowed = 1; 1501 1502 /* 1503 * We have to drop the lock on dvp. gfs_dir_create will 1504 * grab it for a VN_HOLD. 1505 */ 1506 mutex_exit(&dvp->v_lock); 1507 1508 /* 1509 * If dvp allows xattr creation, but not sysattr 1510 * creation, return the real xattr dir vp. We can't 1511 * use the vfs feature mask here because _PC_SATTR_ENABLED 1512 * has vnode-level granularity (e.g. .zfs). 1513 */ 1514 error = VOP_PATHCONF(dvp, _PC_SATTR_ENABLED, &val, cr, NULL); 1515 if (error != 0 || val == 0) 1516 sysattrs_allowed = 0; 1517 1518 if (!xattrs_allowed && !sysattrs_allowed) 1519 return (EINVAL); 1520 1521 if (!sysattrs_allowed) { 1522 struct pathname pn; 1523 char *nm = ""; 1524 1525 error = pn_get(nm, UIO_SYSSPACE, &pn); 1526 if (error) 1527 return (error); 1528 error = VOP_LOOKUP(dvp, nm, vpp, &pn, 1529 flags|LOOKUP_HAVE_SYSATTR_DIR, rootvp, cr, NULL, 1530 NULL, NULL); 1531 pn_free(&pn); 1532 return (error); 1533 } 1534 1535 /* 1536 * Note that we act as if we were given CREATE_XATTR_DIR, 1537 * but only for creation of the GFS directory. 1538 */ 1539 *vpp = gfs_dir_create( 1540 sizeof (xattr_dir_t), dvp, xattr_dir_ops, xattr_dirents, 1541 xattrdir_do_ino, MAXNAMELEN, NULL, xattr_lookup_cb); 1542 mutex_enter(&dvp->v_lock); 1543 if (dvp->v_xattrdir != NULL) { 1544 /* 1545 * We lost the race to create the xattr dir. 1546 * Destroy this one, use the winner. We can't 1547 * just call VN_RELE(*vpp), because the vnode 1548 * is only partially initialized. 1549 */ 1550 gfs_dir_t *dp = (*vpp)->v_data; 1551 1552 ASSERT((*vpp)->v_count == 1); 1553 vn_free(*vpp); 1554 1555 mutex_destroy(&dp->gfsd_lock); 1556 kmem_free(dp->gfsd_static, 1557 dp->gfsd_nstatic * sizeof (gfs_dirent_t)); 1558 kmem_free(dp, dp->gfsd_file.gfs_size); 1559 1560 /* 1561 * There is an implied VN_HOLD(dvp) here. We should 1562 * be doing a VN_RELE(dvp) to clean up the reference 1563 * from *vpp, and then a VN_HOLD(dvp) for the new 1564 * reference. Instead, we just leave the count alone. 1565 */ 1566 1567 *vpp = dvp->v_xattrdir; 1568 VN_HOLD(*vpp); 1569 } else { 1570 (*vpp)->v_flag |= (V_XATTRDIR|V_SYSATTR); 1571 dvp->v_xattrdir = *vpp; 1572 } 1573 } 1574 mutex_exit(&dvp->v_lock); 1575 1576 return (error); 1577 } 1578 1579 int 1580 xattr_dir_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp) 1581 { 1582 int error; 1583 vnode_t *pvp, *dvp; 1584 xattr_fid_t *xfidp; 1585 struct pathname pn; 1586 char *nm; 1587 uint16_t orig_len; 1588 1589 *vpp = NULL; 1590 1591 if (fidp->fid_len < XATTR_FIDSZ) 1592 return (EINVAL); 1593 1594 xfidp = (xattr_fid_t *)fidp; 1595 orig_len = fidp->fid_len; 1596 fidp->fid_len = xfidp->parent_len; 1597 1598 error = VFS_VGET(vfsp, &pvp, fidp); 1599 fidp->fid_len = orig_len; 1600 if (error) 1601 return (error); 1602 1603 /* 1604 * Start by getting the GFS sysattr directory. We might need 1605 * to recreate it during the VOP_LOOKUP. 1606 */ 1607 nm = ""; 1608 error = pn_get(nm, UIO_SYSSPACE, &pn); 1609 if (error) { 1610 VN_RELE(pvp); 1611 return (EINVAL); 1612 } 1613 1614 error = VOP_LOOKUP(pvp, nm, &dvp, &pn, LOOKUP_XATTR|CREATE_XATTR_DIR, 1615 rootvp, CRED(), NULL, NULL, NULL); 1616 pn_free(&pn); 1617 VN_RELE(pvp); 1618 if (error) 1619 return (error); 1620 1621 if (xfidp->dir_offset == 0) { 1622 /* 1623 * If we were looking for the directory, we're done. 1624 */ 1625 *vpp = dvp; 1626 return (0); 1627 } 1628 1629 if (xfidp->dir_offset > XATTRDIR_NENTS) { 1630 VN_RELE(dvp); 1631 return (EINVAL); 1632 } 1633 1634 nm = xattr_dirents[xfidp->dir_offset - 1].gfse_name; 1635 1636 error = pn_get(nm, UIO_SYSSPACE, &pn); 1637 if (error) { 1638 VN_RELE(dvp); 1639 return (EINVAL); 1640 } 1641 1642 error = VOP_LOOKUP(dvp, nm, vpp, &pn, 0, rootvp, CRED(), NULL, 1643 NULL, NULL); 1644 1645 pn_free(&pn); 1646 VN_RELE(dvp); 1647 1648 return (error); 1649 } 1650