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 * Copyright 2017 Nexenta Systems, Inc. All rights reserved. 24 */ 25 /* 26 * SMB Node State Machine 27 * ---------------------- 28 * 29 * 30 * +----------- Creation/Allocation 31 * | 32 * | T0 33 * | 34 * v 35 * +----------------------------+ 36 * | SMB_NODE_STATE_AVAILABLE | 37 * +----------------------------+ 38 * | 39 * | T1 40 * | 41 * v 42 * +-----------------------------+ 43 * | SMB_NODE_STATE_DESTROYING | 44 * +-----------------------------+ 45 * | 46 * | 47 * | T2 48 * | 49 * +----------> Deletion/Free 50 * 51 * Transition T0 52 * 53 * This transition occurs in smb_node_lookup(). If the node looked for is 54 * not found in the has table a new node is created. The reference count is 55 * initialized to 1 and the state initialized to SMB_NODE_STATE_AVAILABLE. 56 * 57 * Transition T1 58 * 59 * This transition occurs in smb_node_release(). If the reference count 60 * drops to zero the state is moved to SMB_NODE_STATE_DESTROYING and no more 61 * reference count will be given out for that node. 62 * 63 * Transition T2 64 * 65 * This transition occurs in smb_node_release(). The structure is deleted. 66 * 67 * Comments 68 * -------- 69 * 70 * The reason the smb node has 2 states is the following synchronization 71 * rule: 72 * 73 * There's a mutex embedded in the node used to protect its fields and 74 * there's a lock embedded in the bucket of the hash table the node belongs 75 * to. To increment or to decrement the reference count the mutex must be 76 * entered. To insert the node into the bucket and to remove it from the 77 * bucket the lock must be entered in RW_WRITER mode. When both (mutex and 78 * lock) have to be entered, the lock has always to be entered first then 79 * the mutex. This prevents a deadlock between smb_node_lookup() and 80 * smb_node_release() from occurring. However, in smb_node_release() when the 81 * reference count drops to zero and triggers the deletion of the node, the 82 * mutex has to be released before entering the lock of the bucket (to 83 * remove the node). This creates a window during which the node that is 84 * about to be freed could be given out by smb_node_lookup(). To close that 85 * window the node is moved to the state SMB_NODE_STATE_DESTROYING before 86 * releasing the mutex. That way, even if smb_node_lookup() finds it, the 87 * state will indicate that the node should be treated as non existent (of 88 * course the state of the node should be tested/updated under the 89 * protection of the mutex). 90 */ 91 #include <smbsrv/smb_kproto.h> 92 #include <smbsrv/smb_fsops.h> 93 #include <smbsrv/smb_kstat.h> 94 #include <sys/ddi.h> 95 #include <sys/extdirent.h> 96 #include <sys/pathname.h> 97 #include <sys/sdt.h> 98 #include <sys/nbmlock.h> 99 #include <fs/fs_reparse.h> 100 101 uint32_t smb_is_executable(char *); 102 static void smb_node_create_audit_buf(smb_node_t *, int); 103 static void smb_node_destroy_audit_buf(smb_node_t *); 104 static void smb_node_audit(smb_node_t *); 105 static smb_node_t *smb_node_alloc(char *, vnode_t *, smb_llist_t *, uint32_t); 106 static void smb_node_free(smb_node_t *); 107 static int smb_node_constructor(void *, void *, int); 108 static void smb_node_destructor(void *, void *); 109 static smb_llist_t *smb_node_get_hash(fsid_t *, smb_attr_t *, uint32_t *); 110 111 static void smb_node_init_reparse(smb_node_t *, smb_attr_t *); 112 static void smb_node_init_system(smb_node_t *); 113 114 #define VALIDATE_DIR_NODE(_dir_, _node_) \ 115 ASSERT((_dir_)->n_magic == SMB_NODE_MAGIC); \ 116 ASSERT(((_dir_)->vp->v_xattrdir) || ((_dir_)->vp->v_type == VDIR)); \ 117 ASSERT((_dir_)->n_dnode != (_node_)); 118 119 /* round sz to DEV_BSIZE block */ 120 #define SMB_ALLOCSZ(sz) (((sz) + DEV_BSIZE-1) & ~(DEV_BSIZE-1)) 121 122 static kmem_cache_t *smb_node_cache = NULL; 123 static smb_llist_t smb_node_hash_table[SMBND_HASH_MASK+1]; 124 static smb_node_t *smb_root_node; 125 126 /* 127 * smb_node_init 128 * 129 * Initialization of the SMB node layer. 130 * 131 * This function is not multi-thread safe. The caller must make sure only one 132 * thread makes the call. 133 */ 134 void 135 smb_node_init(void) 136 { 137 smb_attr_t attr; 138 smb_llist_t *node_hdr; 139 smb_node_t *node; 140 uint32_t hashkey; 141 int i; 142 143 if (smb_node_cache != NULL) 144 return; 145 146 smb_node_cache = kmem_cache_create(SMBSRV_KSTAT_NODE_CACHE, 147 sizeof (smb_node_t), 8, smb_node_constructor, smb_node_destructor, 148 NULL, NULL, NULL, 0); 149 150 for (i = 0; i <= SMBND_HASH_MASK; i++) { 151 smb_llist_constructor(&smb_node_hash_table[i], 152 sizeof (smb_node_t), offsetof(smb_node_t, n_lnd)); 153 } 154 155 /* 156 * The node cache is shared by all zones, so the smb_root_node 157 * must represent the real (global zone) rootdir. 158 * Note intentional use of kcred here. 159 */ 160 attr.sa_mask = SMB_AT_ALL; 161 VERIFY0(smb_vop_getattr(rootdir, NULL, &attr, 0, kcred)); 162 node_hdr = smb_node_get_hash(&rootdir->v_vfsp->vfs_fsid, &attr, 163 &hashkey); 164 node = smb_node_alloc("/", rootdir, node_hdr, hashkey); 165 smb_llist_enter(node_hdr, RW_WRITER); 166 smb_llist_insert_head(node_hdr, node); 167 smb_llist_exit(node_hdr); 168 smb_root_node = node; /* smb_node_release in smb_node_fini */ 169 } 170 171 /* 172 * smb_node_fini 173 * 174 * This function is not multi-thread safe. The caller must make sure only one 175 * thread makes the call. 176 */ 177 void 178 smb_node_fini(void) 179 { 180 int i; 181 182 if (smb_root_node != NULL) { 183 smb_node_release(smb_root_node); 184 smb_root_node = NULL; 185 } 186 187 if (smb_node_cache == NULL) 188 return; 189 190 #ifdef DEBUG 191 for (i = 0; i <= SMBND_HASH_MASK; i++) { 192 smb_llist_t *bucket; 193 smb_node_t *node; 194 195 /* 196 * The following sequence is just intended for sanity check. 197 * This will have to be modified when the code goes into 198 * production. 199 * 200 * The SMB node hash table should be emtpy at this point. If the 201 * hash table is not empty a panic will be triggered. 202 * 203 * The reason why SMB nodes are still remaining in the hash 204 * table is problably due to a mismatch between calls to 205 * smb_node_lookup() and smb_node_release(). You must track that 206 * down. 207 */ 208 bucket = &smb_node_hash_table[i]; 209 node = smb_llist_head(bucket); 210 while (node != NULL) { 211 cmn_err(CE_NOTE, "leaked node: 0x%p %s", 212 (void *)node, node->od_name); 213 node = smb_llist_next(bucket, node); 214 } 215 } 216 #endif 217 218 for (i = 0; i <= SMBND_HASH_MASK; i++) { 219 smb_llist_destructor(&smb_node_hash_table[i]); 220 } 221 kmem_cache_destroy(smb_node_cache); 222 smb_node_cache = NULL; 223 } 224 225 /* 226 * smb_node_lookup() 227 * 228 * NOTE: This routine should only be called by the file system interface layer, 229 * and not by SMB. 230 * 231 * smb_node_lookup() is called upon successful lookup, mkdir, and create 232 * (for both non-streams and streams). In each of these cases, a held vnode is 233 * passed into this routine. If a new smb_node is created it will take its 234 * own hold on the vnode. The caller's hold therefore still belongs to, and 235 * should be released by, the caller. 236 * 237 * A reference is taken on the smb_node whether found in the hash table 238 * or newly created. 239 * 240 * If an smb_node needs to be created, a reference is also taken on the 241 * dnode (if passed in). 242 * 243 * See smb_node_release() for details on the release of these references. 244 */ 245 246 /*ARGSUSED*/ 247 smb_node_t * 248 smb_node_lookup( 249 struct smb_request *sr, 250 struct open_param *op, 251 cred_t *cred, 252 vnode_t *vp, 253 char *od_name, 254 smb_node_t *dnode, 255 smb_node_t *unode) 256 { 257 smb_llist_t *node_hdr; 258 smb_node_t *node; 259 smb_attr_t attr; 260 uint32_t hashkey = 0; 261 fsid_t fsid; 262 int error; 263 krw_t lock_mode; 264 vnode_t *unnamed_vp = NULL; 265 266 /* 267 * smb_vop_getattr() is called here instead of smb_fsop_getattr(), 268 * because the node may not yet exist. We also do not want to call 269 * it with the list lock held. 270 */ 271 272 if (unode) 273 unnamed_vp = unode->vp; 274 275 /* 276 * This getattr is performed on behalf of the server 277 * that's why kcred is used not the user's cred 278 */ 279 attr.sa_mask = SMB_AT_ALL; 280 error = smb_vop_getattr(vp, unnamed_vp, &attr, 0, zone_kcred()); 281 if (error) 282 return (NULL); 283 284 if (sr && sr->tid_tree) { 285 /* 286 * The fsid for a file is that of the tree, even 287 * if the file resides in a different mountpoint 288 * under the share. 289 */ 290 fsid = SMB_TREE_FSID(sr->tid_tree); 291 } else { 292 /* 293 * This should be getting executed only for the 294 * tree root smb_node. 295 */ 296 fsid = vp->v_vfsp->vfs_fsid; 297 } 298 299 node_hdr = smb_node_get_hash(&fsid, &attr, &hashkey); 300 lock_mode = RW_READER; 301 302 smb_llist_enter(node_hdr, lock_mode); 303 for (;;) { 304 node = list_head(&node_hdr->ll_list); 305 while (node) { 306 ASSERT(node->n_magic == SMB_NODE_MAGIC); 307 ASSERT(node->n_hash_bucket == node_hdr); 308 if ((node->n_hashkey == hashkey) && (node->vp == vp)) { 309 mutex_enter(&node->n_mutex); 310 DTRACE_PROBE1(smb_node_lookup_hit, 311 smb_node_t *, node); 312 switch (node->n_state) { 313 case SMB_NODE_STATE_AVAILABLE: 314 /* The node was found. */ 315 node->n_refcnt++; 316 if ((node->n_dnode == NULL) && 317 (dnode != NULL) && 318 (node != dnode) && 319 (strcmp(od_name, "..") != 0) && 320 (strcmp(od_name, ".") != 0)) { 321 VALIDATE_DIR_NODE(dnode, node); 322 node->n_dnode = dnode; 323 smb_node_ref(dnode); 324 } 325 326 smb_node_audit(node); 327 mutex_exit(&node->n_mutex); 328 smb_llist_exit(node_hdr); 329 return (node); 330 331 case SMB_NODE_STATE_DESTROYING: 332 /* 333 * Although the node exists it is about 334 * to be destroyed. We act as it hasn't 335 * been found. 336 */ 337 mutex_exit(&node->n_mutex); 338 break; 339 default: 340 /* 341 * Although the node exists it is in an 342 * unknown state. We act as it hasn't 343 * been found. 344 */ 345 ASSERT(0); 346 mutex_exit(&node->n_mutex); 347 break; 348 } 349 } 350 node = smb_llist_next(node_hdr, node); 351 } 352 if ((lock_mode == RW_READER) && smb_llist_upgrade(node_hdr)) { 353 lock_mode = RW_WRITER; 354 continue; 355 } 356 break; 357 } 358 node = smb_node_alloc(od_name, vp, node_hdr, hashkey); 359 smb_node_init_reparse(node, &attr); 360 361 if (op) 362 node->flags |= smb_is_executable(op->fqi.fq_last_comp); 363 364 if (dnode) { 365 smb_node_ref(dnode); 366 node->n_dnode = dnode; 367 ASSERT(dnode->n_dnode != node); 368 ASSERT((dnode->vp->v_xattrdir) || 369 (dnode->vp->v_type == VDIR)); 370 } 371 372 if (unode) { 373 smb_node_ref(unode); 374 node->n_unode = unode; 375 } 376 377 smb_node_init_system(node); 378 379 DTRACE_PROBE1(smb_node_lookup_miss, smb_node_t *, node); 380 smb_node_audit(node); 381 smb_llist_insert_head(node_hdr, node); 382 smb_llist_exit(node_hdr); 383 return (node); 384 } 385 386 /* 387 * smb_stream_node_lookup() 388 * 389 * Note: stream_name (the name that will be stored in the "od_name" field 390 * of a stream's smb_node) is the same as the on-disk name for the stream 391 * except that it does not have SMB_STREAM_PREFIX prepended. 392 */ 393 394 smb_node_t * 395 smb_stream_node_lookup(smb_request_t *sr, cred_t *cr, smb_node_t *fnode, 396 vnode_t *xattrdirvp, vnode_t *vp, char *stream_name) 397 { 398 smb_node_t *xattrdir_node; 399 smb_node_t *snode; 400 401 xattrdir_node = smb_node_lookup(sr, NULL, cr, xattrdirvp, XATTR_DIR, 402 fnode, NULL); 403 404 if (xattrdir_node == NULL) 405 return (NULL); 406 407 snode = smb_node_lookup(sr, NULL, cr, vp, stream_name, xattrdir_node, 408 fnode); 409 410 (void) smb_node_release(xattrdir_node); 411 return (snode); 412 } 413 414 415 /* 416 * This function should be called whenever a reference is needed on an 417 * smb_node pointer. The copy of an smb_node pointer from one non-local 418 * data structure to another requires a reference to be taken on the smb_node 419 * (unless the usage is localized). Each data structure deallocation routine 420 * will call smb_node_release() on its smb_node pointers. 421 * 422 * In general, an smb_node pointer residing in a structure should never be 423 * stale. A node pointer may be NULL, however, and care should be taken 424 * prior to calling smb_node_ref(), which ASSERTs that the pointer is valid. 425 * Care also needs to be taken with respect to racing deallocations of a 426 * structure. 427 */ 428 void 429 smb_node_ref(smb_node_t *node) 430 { 431 SMB_NODE_VALID(node); 432 433 mutex_enter(&node->n_mutex); 434 switch (node->n_state) { 435 case SMB_NODE_STATE_AVAILABLE: 436 node->n_refcnt++; 437 ASSERT(node->n_refcnt); 438 DTRACE_PROBE1(smb_node_ref_exit, smb_node_t *, node); 439 smb_node_audit(node); 440 break; 441 default: 442 SMB_PANIC(); 443 } 444 mutex_exit(&node->n_mutex); 445 } 446 447 /* 448 * smb_node_lookup() takes a hold on an smb_node, whether found in the 449 * hash table or newly created. This hold is expected to be released 450 * in the following manner. 451 * 452 * smb_node_lookup() takes an address of an smb_node pointer. This should 453 * be getting passed down via a lookup (whether path name or component), mkdir, 454 * create. If the original smb_node pointer resides in a data structure, then 455 * the deallocation routine for the data structure is responsible for calling 456 * smb_node_release() on the smb_node pointer. Alternatively, 457 * smb_node_release() can be called as soon as the smb_node pointer is no longer 458 * needed. In this case, callers are responsible for setting an embedded 459 * pointer to NULL if it is known that the last reference is being released. 460 * 461 * If the passed-in address of the smb_node pointer belongs to a local variable, 462 * then the caller with the local variable should call smb_node_release() 463 * directly. 464 * 465 * smb_node_release() itself will call smb_node_release() on a node's n_dnode, 466 * as smb_node_lookup() takes a hold on dnode. 467 */ 468 void 469 smb_node_release(smb_node_t *node) 470 { 471 SMB_NODE_VALID(node); 472 473 mutex_enter(&node->n_mutex); 474 ASSERT(node->n_refcnt); 475 DTRACE_PROBE1(smb_node_release, smb_node_t *, node); 476 if (--node->n_refcnt == 0) { 477 switch (node->n_state) { 478 479 case SMB_NODE_STATE_AVAILABLE: 480 node->n_state = SMB_NODE_STATE_DESTROYING; 481 mutex_exit(&node->n_mutex); 482 483 smb_llist_enter(node->n_hash_bucket, RW_WRITER); 484 smb_llist_remove(node->n_hash_bucket, node); 485 smb_llist_exit(node->n_hash_bucket); 486 487 /* 488 * Check if the file was deleted 489 */ 490 if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) { 491 smb_node_delete_on_close(node); 492 } 493 494 if (node->n_dnode) { 495 ASSERT(node->n_dnode->n_magic == 496 SMB_NODE_MAGIC); 497 smb_node_release(node->n_dnode); 498 } 499 500 if (node->n_unode) { 501 ASSERT(node->n_unode->n_magic == 502 SMB_NODE_MAGIC); 503 smb_node_release(node->n_unode); 504 } 505 506 smb_node_free(node); 507 return; 508 509 default: 510 SMB_PANIC(); 511 } 512 } 513 smb_node_audit(node); 514 mutex_exit(&node->n_mutex); 515 } 516 517 void 518 smb_node_delete_on_close(smb_node_t *node) 519 { 520 smb_node_t *d_snode; 521 int rc = 0; 522 uint32_t flags = 0; 523 524 d_snode = node->n_dnode; 525 526 ASSERT((node->flags & NODE_FLAGS_DELETE_ON_CLOSE) != 0); 527 528 node->flags &= ~NODE_FLAGS_DELETE_ON_CLOSE; 529 node->flags |= NODE_FLAGS_DELETE_COMMITTED; 530 flags = node->n_delete_on_close_flags; 531 ASSERT(node->od_name != NULL); 532 533 if (smb_node_is_dir(node)) 534 rc = smb_fsop_rmdir(0, node->delete_on_close_cred, 535 d_snode, node->od_name, flags); 536 else 537 rc = smb_fsop_remove(0, node->delete_on_close_cred, 538 d_snode, node->od_name, flags); 539 crfree(node->delete_on_close_cred); 540 node->delete_on_close_cred = NULL; 541 542 if (rc != 0) 543 cmn_err(CE_WARN, "File %s could not be removed, rc=%d\n", 544 node->od_name, rc); 545 DTRACE_PROBE2(smb_node_delete_on_close, int, rc, smb_node_t *, node); 546 } 547 548 /* 549 * smb_node_rename() 550 * 551 */ 552 void 553 smb_node_rename( 554 smb_node_t *from_dnode, 555 smb_node_t *ret_node, 556 smb_node_t *to_dnode, 557 char *to_name) 558 { 559 SMB_NODE_VALID(from_dnode); 560 SMB_NODE_VALID(to_dnode); 561 SMB_NODE_VALID(ret_node); 562 563 smb_node_ref(to_dnode); 564 mutex_enter(&ret_node->n_mutex); 565 switch (ret_node->n_state) { 566 case SMB_NODE_STATE_AVAILABLE: 567 ret_node->n_dnode = to_dnode; 568 mutex_exit(&ret_node->n_mutex); 569 ASSERT(to_dnode->n_dnode != ret_node); 570 ASSERT((to_dnode->vp->v_xattrdir) || 571 (to_dnode->vp->v_type == VDIR)); 572 smb_node_release(from_dnode); 573 (void) strcpy(ret_node->od_name, to_name); 574 /* 575 * XXX Need to update attributes? 576 */ 577 break; 578 default: 579 SMB_PANIC(); 580 } 581 } 582 583 /* 584 * Find/create an SMB node for the root of this zone and store it 585 * in *svrootp. Also create nodes leading to this directory. 586 */ 587 int 588 smb_node_root_init(smb_server_t *sv, smb_node_t **svrootp) 589 { 590 zone_t *zone = curzone; 591 int error; 592 593 ASSERT(zone->zone_id == sv->sv_zid); 594 if (smb_root_node == NULL) 595 return (ENOENT); 596 597 /* 598 * We're getting smb nodes below the zone root here, 599 * so need to use kcred, not zone_kcred(). 600 */ 601 error = smb_pathname(NULL, zone->zone_rootpath, 0, 602 smb_root_node, smb_root_node, NULL, svrootp, kcred); 603 604 return (error); 605 } 606 607 /* 608 * Helper function for smb_node_set_delete_on_close(). Assumes node is a dir. 609 * Return 0 if this is an empty dir. Otherwise return a NT_STATUS code. 610 * Unfortunately, to find out if a directory is empty, we have to read it 611 * and check for anything other than "." or ".." in the readdir buf. 612 */ 613 static uint32_t 614 smb_rmdir_possible(smb_node_t *n, uint32_t flags) 615 { 616 ASSERT(n->vp->v_type == VDIR); 617 char buf[512]; /* Only large enough to see if the dir is empty. */ 618 int eof, bsize = sizeof (buf), reclen = 0; 619 char *name; 620 boolean_t edp = vfs_has_feature(n->vp->v_vfsp, VFSFT_DIRENTFLAGS); 621 622 union { 623 char *u_bufptr; 624 struct edirent *u_edp; 625 struct dirent64 *u_dp; 626 } u; 627 #define bufptr u.u_bufptr 628 #define extdp u.u_edp 629 #define dp u.u_dp 630 631 if (smb_vop_readdir(n->vp, 0, buf, &bsize, &eof, flags, zone_kcred())) 632 return (NT_STATUS_INTERNAL_ERROR); 633 if (bsize == 0) 634 return (0); /* empty dir */ 635 bufptr = buf; 636 while ((bufptr += reclen) < buf + bsize) { 637 if (edp) { 638 reclen = extdp->ed_reclen; 639 name = extdp->ed_name; 640 } else { 641 reclen = dp->d_reclen; 642 name = dp->d_name; 643 } 644 if (strcmp(name, ".") != 0 && strcmp(name, "..") != 0) 645 return (NT_STATUS_DIRECTORY_NOT_EMPTY); 646 } 647 return (0); 648 } 649 650 /* 651 * When DeleteOnClose is set on an smb_node, the common open code will 652 * reject subsequent open requests for the file. Observation of Windows 653 * 2000 indicates that subsequent opens should be allowed (assuming 654 * there would be no sharing violation) until the file is closed using 655 * the fid on which the DeleteOnClose was requested. 656 * 657 * If there are multiple opens with delete-on-close create options, 658 * whichever the first file handle is closed will trigger the node to be 659 * marked as delete-on-close. The credentials of that ofile will be used 660 * as the delete-on-close credentials of the node. 661 * 662 * Note that "read-only" tests have already happened before this call. 663 */ 664 uint32_t 665 smb_node_set_delete_on_close(smb_node_t *node, cred_t *cr, uint32_t flags) 666 { 667 uint32_t status; 668 669 /* 670 * If the directory is not empty we should fail setting del-on-close 671 * with STATUS_DIRECTORY_NOT_EMPTY. see MS's 672 * "File System Behavior Overview" doc section 4.3.2 673 */ 674 if (smb_node_is_dir(node)) { 675 status = smb_rmdir_possible(node, flags); 676 if (status != 0) { 677 return (status); 678 } 679 } 680 681 mutex_enter(&node->n_mutex); 682 if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) { 683 /* It was already marked. We're done. */ 684 mutex_exit(&node->n_mutex); 685 return (NT_STATUS_SUCCESS); 686 } 687 688 crhold(cr); 689 node->delete_on_close_cred = cr; 690 node->n_delete_on_close_flags = flags; 691 node->flags |= NODE_FLAGS_DELETE_ON_CLOSE; 692 mutex_exit(&node->n_mutex); 693 694 /* 695 * Tell any change notify calls to close their handles 696 * and get out of the way. FILE_ACTION_DELETE_PENDING 697 * is a special, internal-only action for this purpose. 698 */ 699 smb_node_notify_change(node, FILE_ACTION_DELETE_PENDING, NULL); 700 701 return (NT_STATUS_SUCCESS); 702 } 703 704 void 705 smb_node_reset_delete_on_close(smb_node_t *node) 706 { 707 mutex_enter(&node->n_mutex); 708 if (node->flags & NODE_FLAGS_DELETE_ON_CLOSE) { 709 node->flags &= ~NODE_FLAGS_DELETE_ON_CLOSE; 710 crfree(node->delete_on_close_cred); 711 node->delete_on_close_cred = NULL; 712 node->n_delete_on_close_flags = 0; 713 } 714 mutex_exit(&node->n_mutex); 715 } 716 717 /* 718 * smb_node_open_check 719 * 720 * check file sharing rules for current open request 721 * against all existing opens for a file. 722 * 723 * Returns NT_STATUS_SHARING_VIOLATION if there is any 724 * sharing conflict, otherwise returns NT_STATUS_SUCCESS. 725 */ 726 uint32_t 727 smb_node_open_check(smb_node_t *node, uint32_t desired_access, 728 uint32_t share_access) 729 { 730 smb_ofile_t *of; 731 uint32_t status; 732 733 SMB_NODE_VALID(node); 734 735 smb_llist_enter(&node->n_ofile_list, RW_READER); 736 of = smb_llist_head(&node->n_ofile_list); 737 while (of) { 738 status = smb_ofile_open_check(of, desired_access, share_access); 739 740 switch (status) { 741 case NT_STATUS_INVALID_HANDLE: 742 case NT_STATUS_SUCCESS: 743 of = smb_llist_next(&node->n_ofile_list, of); 744 break; 745 default: 746 ASSERT(status == NT_STATUS_SHARING_VIOLATION); 747 smb_llist_exit(&node->n_ofile_list); 748 return (status); 749 } 750 } 751 752 smb_llist_exit(&node->n_ofile_list); 753 return (NT_STATUS_SUCCESS); 754 } 755 756 uint32_t 757 smb_node_rename_check(smb_node_t *node) 758 { 759 smb_ofile_t *of; 760 uint32_t status; 761 762 SMB_NODE_VALID(node); 763 764 /* 765 * Intra-CIFS check 766 */ 767 smb_llist_enter(&node->n_ofile_list, RW_READER); 768 of = smb_llist_head(&node->n_ofile_list); 769 while (of) { 770 status = smb_ofile_rename_check(of); 771 772 switch (status) { 773 case NT_STATUS_INVALID_HANDLE: 774 case NT_STATUS_SUCCESS: 775 of = smb_llist_next(&node->n_ofile_list, of); 776 break; 777 default: 778 ASSERT(status == NT_STATUS_SHARING_VIOLATION); 779 smb_llist_exit(&node->n_ofile_list); 780 return (status); 781 } 782 } 783 smb_llist_exit(&node->n_ofile_list); 784 return (NT_STATUS_SUCCESS); 785 } 786 787 uint32_t 788 smb_node_delete_check(smb_node_t *node) 789 { 790 smb_ofile_t *of; 791 uint32_t status; 792 793 SMB_NODE_VALID(node); 794 795 if (smb_node_is_dir(node)) 796 return (NT_STATUS_SUCCESS); 797 798 if (smb_node_is_reparse(node)) 799 return (NT_STATUS_ACCESS_DENIED); 800 801 /* 802 * intra-CIFS check 803 */ 804 smb_llist_enter(&node->n_ofile_list, RW_READER); 805 of = smb_llist_head(&node->n_ofile_list); 806 while (of) { 807 status = smb_ofile_delete_check(of); 808 809 switch (status) { 810 case NT_STATUS_INVALID_HANDLE: 811 case NT_STATUS_SUCCESS: 812 of = smb_llist_next(&node->n_ofile_list, of); 813 break; 814 default: 815 ASSERT(status == NT_STATUS_SHARING_VIOLATION); 816 smb_llist_exit(&node->n_ofile_list); 817 return (status); 818 } 819 } 820 smb_llist_exit(&node->n_ofile_list); 821 return (NT_STATUS_SUCCESS); 822 } 823 824 /* 825 * smb_node_share_check 826 * 827 * Returns: TRUE - ofiles have non-zero share access 828 * B_FALSE - ofile with share access NONE. 829 */ 830 boolean_t 831 smb_node_share_check(smb_node_t *node) 832 { 833 smb_ofile_t *of; 834 boolean_t status = B_TRUE; 835 836 SMB_NODE_VALID(node); 837 838 smb_llist_enter(&node->n_ofile_list, RW_READER); 839 of = smb_llist_head(&node->n_ofile_list); 840 if (of) 841 status = smb_ofile_share_check(of); 842 smb_llist_exit(&node->n_ofile_list); 843 844 return (status); 845 } 846 847 /* 848 * SMB Change Notification 849 */ 850 851 void 852 smb_node_fcn_subscribe(smb_node_t *node) 853 { 854 855 mutex_enter(&node->n_mutex); 856 if (node->n_fcn_count == 0) 857 (void) smb_fem_fcn_install(node); 858 node->n_fcn_count++; 859 mutex_exit(&node->n_mutex); 860 } 861 862 void 863 smb_node_fcn_unsubscribe(smb_node_t *node) 864 { 865 866 mutex_enter(&node->n_mutex); 867 node->n_fcn_count--; 868 if (node->n_fcn_count == 0) 869 smb_fem_fcn_uninstall(node); 870 mutex_exit(&node->n_mutex); 871 } 872 873 void 874 smb_node_notify_change(smb_node_t *node, uint_t action, const char *name) 875 { 876 smb_ofile_t *of; 877 878 SMB_NODE_VALID(node); 879 880 smb_llist_enter(&node->n_ofile_list, RW_READER); 881 of = smb_llist_head(&node->n_ofile_list); 882 while (of) { 883 /* 884 * We'd rather deliver events only to ofiles that have 885 * subscribed. There's no explicit synchronization with 886 * where this flag is set, but other actions cause this 887 * value to reach visibility soon enough for events to 888 * start arriving by the time we need them to start. 889 * Once nc_subscribed is set, it stays set for the 890 * life of the ofile. 891 */ 892 if (of->f_notify.nc_subscribed) 893 smb_notify_ofile(of, action, name); 894 of = smb_llist_next(&node->n_ofile_list, of); 895 } 896 smb_llist_exit(&node->n_ofile_list); 897 898 /* 899 * After changes that add or remove a name, 900 * we know the directory attributes changed, 901 * and we can tell the immediate parent. 902 */ 903 switch (action) { 904 case FILE_ACTION_ADDED: 905 case FILE_ACTION_REMOVED: 906 case FILE_ACTION_RENAMED_NEW_NAME: 907 /* 908 * Note: FILE_ACTION_RENAMED_OLD_NAME is intentionally 909 * omitted, because it's always followed by another 910 * event with FILE_ACTION_RENAMED_NEW_NAME posted to 911 * the same directory, and we only need/want one. 912 */ 913 if (node->n_dnode != NULL) { 914 smb_node_notify_change(node->n_dnode, 915 FILE_ACTION_MODIFIED, node->od_name); 916 } 917 break; 918 } 919 920 /* 921 * If we wanted to support recursive notify events 922 * (where a notify call on some directory receives 923 * events from all objects below that directory), 924 * we might deliver _SUBDIR_CHANGED to all our 925 * parents, grandparents etc, here. However, we 926 * don't currently subscribe to changes on all the 927 * child (and grandchild) objects that would be 928 * needed to make that work. It's prohibitively 929 * expensive to do that, and support for recursive 930 * notify is optional anyway, so don't bother. 931 */ 932 } 933 934 /* 935 * smb_node_start_crit() 936 * 937 * Enter critical region for share reservations. 938 * See comments above smb_fsop_shrlock(). 939 */ 940 void 941 smb_node_start_crit(smb_node_t *node, krw_t mode) 942 { 943 rw_enter(&node->n_lock, mode); 944 nbl_start_crit(node->vp, mode); 945 } 946 947 /* 948 * smb_node_end_crit() 949 * 950 * Exit critical region for share reservations. 951 */ 952 void 953 smb_node_end_crit(smb_node_t *node) 954 { 955 nbl_end_crit(node->vp); 956 rw_exit(&node->n_lock); 957 } 958 959 int 960 smb_node_in_crit(smb_node_t *node) 961 { 962 return (nbl_in_crit(node->vp) && RW_LOCK_HELD(&node->n_lock)); 963 } 964 965 void 966 smb_node_rdlock(smb_node_t *node) 967 { 968 rw_enter(&node->n_lock, RW_READER); 969 } 970 971 void 972 smb_node_wrlock(smb_node_t *node) 973 { 974 rw_enter(&node->n_lock, RW_WRITER); 975 } 976 977 void 978 smb_node_unlock(smb_node_t *node) 979 { 980 rw_exit(&node->n_lock); 981 } 982 983 void 984 smb_node_add_ofile(smb_node_t *node, smb_ofile_t *of) 985 { 986 SMB_NODE_VALID(node); 987 988 smb_llist_enter(&node->n_ofile_list, RW_WRITER); 989 smb_llist_insert_tail(&node->n_ofile_list, of); 990 smb_llist_exit(&node->n_ofile_list); 991 } 992 993 void 994 smb_node_rem_ofile(smb_node_t *node, smb_ofile_t *of) 995 { 996 SMB_NODE_VALID(node); 997 998 smb_llist_enter(&node->n_ofile_list, RW_WRITER); 999 smb_llist_remove(&node->n_ofile_list, of); 1000 smb_llist_exit(&node->n_ofile_list); 1001 } 1002 1003 /* 1004 * smb_node_inc_open_ofiles 1005 */ 1006 void 1007 smb_node_inc_open_ofiles(smb_node_t *node) 1008 { 1009 SMB_NODE_VALID(node); 1010 atomic_inc_32(&node->n_open_count); 1011 } 1012 1013 /* 1014 * smb_node_dec_open_ofiles 1015 * returns new value 1016 */ 1017 uint32_t 1018 smb_node_dec_open_ofiles(smb_node_t *node) 1019 { 1020 SMB_NODE_VALID(node); 1021 return (atomic_dec_32_nv(&node->n_open_count)); 1022 } 1023 1024 /* 1025 * smb_node_inc_opening_count 1026 */ 1027 void 1028 smb_node_inc_opening_count(smb_node_t *node) 1029 { 1030 SMB_NODE_VALID(node); 1031 atomic_inc_32(&node->n_opening_count); 1032 } 1033 1034 /* 1035 * smb_node_dec_opening_count 1036 */ 1037 void 1038 smb_node_dec_opening_count(smb_node_t *node) 1039 { 1040 SMB_NODE_VALID(node); 1041 atomic_dec_32(&node->n_opening_count); 1042 } 1043 1044 /* 1045 * smb_node_getmntpath 1046 */ 1047 int 1048 smb_node_getmntpath(smb_node_t *node, char *buf, uint32_t buflen) 1049 { 1050 vnode_t *vp, *root_vp; 1051 vfs_t *vfsp; 1052 int err; 1053 1054 ASSERT(node); 1055 ASSERT(node->vp); 1056 ASSERT(node->vp->v_vfsp); 1057 1058 vp = node->vp; 1059 vfsp = vp->v_vfsp; 1060 1061 if (VFS_ROOT(vfsp, &root_vp)) 1062 return (ENOENT); 1063 1064 VN_HOLD(vp); 1065 1066 /* NULL is passed in as we want to start at "/" */ 1067 err = vnodetopath(NULL, root_vp, buf, buflen, zone_kcred()); 1068 1069 VN_RELE(vp); 1070 VN_RELE(root_vp); 1071 return (err); 1072 } 1073 1074 /* 1075 * smb_node_getshrpath 1076 * 1077 * Determine the absolute pathname of 'node' within the share (tree). 1078 * For example if the node represents file "test1.txt" in directory 1079 * "dir1" the pathname would be: \dir1\test1.txt 1080 */ 1081 int 1082 smb_node_getshrpath(smb_node_t *node, smb_tree_t *tree, 1083 char *buf, uint32_t buflen) 1084 { 1085 int rc; 1086 1087 ASSERT(node); 1088 ASSERT(tree); 1089 ASSERT(tree->t_snode); 1090 1091 rc = smb_node_getpath(node, tree->t_snode->vp, buf, buflen); 1092 (void) strsubst(buf, '/', '\\'); 1093 return (rc); 1094 } 1095 1096 /* 1097 * smb_node_getpath 1098 * 1099 * Determine the absolute pathname of 'node' from 'rootvp'. 1100 * 1101 * Using vnodetopath is only reliable for directory nodes (due to 1102 * its reliance on the DNLC for non-directory nodes). Thus, if node 1103 * represents a file, construct the pathname for the parent dnode 1104 * and append filename. 1105 * If node represents a named stream, construct the pathname for the 1106 * associated unnamed stream and append the stream name. 1107 * 1108 * The pathname returned in buf will be '/' separated. 1109 */ 1110 int 1111 smb_node_getpath(smb_node_t *node, vnode_t *rootvp, char *buf, uint32_t buflen) 1112 { 1113 int rc; 1114 vnode_t *vp; 1115 smb_node_t *unode, *dnode; 1116 cred_t *kcr = zone_kcred(); 1117 1118 unode = (SMB_IS_STREAM(node)) ? node->n_unode : node; 1119 dnode = (smb_node_is_dir(unode)) ? unode : unode->n_dnode; 1120 1121 /* find path to directory node */ 1122 vp = dnode->vp; 1123 VN_HOLD(vp); 1124 if (rootvp) { 1125 VN_HOLD(rootvp); 1126 rc = vnodetopath(rootvp, vp, buf, buflen, kcr); 1127 VN_RELE(rootvp); 1128 } else { 1129 rc = vnodetopath(NULL, vp, buf, buflen, kcr); 1130 } 1131 VN_RELE(vp); 1132 1133 if (rc != 0) 1134 return (rc); 1135 1136 /* append filename if necessary */ 1137 if (!smb_node_is_dir(unode)) { 1138 if (buf[strlen(buf) - 1] != '/') 1139 (void) strlcat(buf, "/", buflen); 1140 (void) strlcat(buf, unode->od_name, buflen); 1141 } 1142 1143 /* append named stream name if necessary */ 1144 if (SMB_IS_STREAM(node)) 1145 (void) strlcat(buf, node->od_name, buflen); 1146 1147 return (rc); 1148 } 1149 1150 /* 1151 * smb_node_alloc 1152 */ 1153 static smb_node_t * 1154 smb_node_alloc( 1155 char *od_name, 1156 vnode_t *vp, 1157 smb_llist_t *bucket, 1158 uint32_t hashkey) 1159 { 1160 smb_node_t *node; 1161 vnode_t *root_vp; 1162 1163 node = kmem_cache_alloc(smb_node_cache, KM_SLEEP); 1164 1165 if (node->n_audit_buf != NULL) 1166 node->n_audit_buf->anb_index = 0; 1167 1168 node->flags = 0; 1169 VN_HOLD(vp); 1170 node->vp = vp; 1171 node->n_refcnt = 1; 1172 node->n_hash_bucket = bucket; 1173 node->n_hashkey = hashkey; 1174 node->n_open_count = 0; 1175 node->n_allocsz = 0; 1176 node->n_dnode = NULL; 1177 node->n_unode = NULL; 1178 node->delete_on_close_cred = NULL; 1179 node->n_delete_on_close_flags = 0; 1180 node->n_oplock.ol_fem = B_FALSE; 1181 node->n_oplock.ol_xthread = NULL; 1182 node->n_oplock.ol_count = 0; 1183 node->n_oplock.ol_break = SMB_OPLOCK_NO_BREAK; 1184 1185 (void) strlcpy(node->od_name, od_name, sizeof (node->od_name)); 1186 if (strcmp(od_name, XATTR_DIR) == 0) 1187 node->flags |= NODE_XATTR_DIR; 1188 1189 if (VFS_ROOT(vp->v_vfsp, &root_vp) == 0) { 1190 if (vp == root_vp) 1191 node->flags |= NODE_FLAGS_VFSROOT; 1192 VN_RELE(root_vp); 1193 } 1194 1195 node->n_state = SMB_NODE_STATE_AVAILABLE; 1196 node->n_magic = SMB_NODE_MAGIC; 1197 1198 return (node); 1199 } 1200 1201 /* 1202 * smb_node_free 1203 */ 1204 static void 1205 smb_node_free(smb_node_t *node) 1206 { 1207 SMB_NODE_VALID(node); 1208 1209 node->n_magic = 0; 1210 VERIFY(!list_link_active(&node->n_lnd)); 1211 VERIFY(node->n_lock_list.ll_count == 0); 1212 VERIFY(node->n_wlock_list.ll_count == 0); 1213 VERIFY(node->n_ofile_list.ll_count == 0); 1214 VERIFY(node->n_oplock.ol_count == 0); 1215 VERIFY(node->n_oplock.ol_xthread == NULL); 1216 VERIFY(node->n_oplock.ol_fem == B_FALSE); 1217 VERIFY(MUTEX_NOT_HELD(&node->n_mutex)); 1218 VERIFY(!RW_LOCK_HELD(&node->n_lock)); 1219 VN_RELE(node->vp); 1220 kmem_cache_free(smb_node_cache, node); 1221 } 1222 1223 /* 1224 * smb_node_constructor 1225 */ 1226 static int 1227 smb_node_constructor(void *buf, void *un, int kmflags) 1228 { 1229 _NOTE(ARGUNUSED(kmflags, un)) 1230 1231 smb_node_t *node = (smb_node_t *)buf; 1232 1233 bzero(node, sizeof (smb_node_t)); 1234 1235 smb_llist_constructor(&node->n_ofile_list, sizeof (smb_ofile_t), 1236 offsetof(smb_ofile_t, f_node_lnd)); 1237 smb_llist_constructor(&node->n_lock_list, sizeof (smb_lock_t), 1238 offsetof(smb_lock_t, l_lnd)); 1239 smb_llist_constructor(&node->n_wlock_list, sizeof (smb_lock_t), 1240 offsetof(smb_lock_t, l_lnd)); 1241 cv_init(&node->n_oplock.ol_cv, NULL, CV_DEFAULT, NULL); 1242 mutex_init(&node->n_oplock.ol_mutex, NULL, MUTEX_DEFAULT, NULL); 1243 list_create(&node->n_oplock.ol_grants, sizeof (smb_oplock_grant_t), 1244 offsetof(smb_oplock_grant_t, og_lnd)); 1245 rw_init(&node->n_lock, NULL, RW_DEFAULT, NULL); 1246 mutex_init(&node->n_mutex, NULL, MUTEX_DEFAULT, NULL); 1247 smb_node_create_audit_buf(node, kmflags); 1248 return (0); 1249 } 1250 1251 /* 1252 * smb_node_destructor 1253 */ 1254 static void 1255 smb_node_destructor(void *buf, void *un) 1256 { 1257 _NOTE(ARGUNUSED(un)) 1258 1259 smb_node_t *node = (smb_node_t *)buf; 1260 1261 smb_node_destroy_audit_buf(node); 1262 mutex_destroy(&node->n_mutex); 1263 rw_destroy(&node->n_lock); 1264 cv_destroy(&node->n_oplock.ol_cv); 1265 mutex_destroy(&node->n_oplock.ol_mutex); 1266 smb_llist_destructor(&node->n_lock_list); 1267 smb_llist_destructor(&node->n_wlock_list); 1268 smb_llist_destructor(&node->n_ofile_list); 1269 list_destroy(&node->n_oplock.ol_grants); 1270 } 1271 1272 /* 1273 * smb_node_create_audit_buf 1274 */ 1275 static void 1276 smb_node_create_audit_buf(smb_node_t *node, int kmflags) 1277 { 1278 smb_audit_buf_node_t *abn; 1279 1280 if (smb_audit_flags & SMB_AUDIT_NODE) { 1281 abn = kmem_zalloc(sizeof (smb_audit_buf_node_t), kmflags); 1282 abn->anb_max_index = SMB_AUDIT_BUF_MAX_REC - 1; 1283 node->n_audit_buf = abn; 1284 } 1285 } 1286 1287 /* 1288 * smb_node_destroy_audit_buf 1289 */ 1290 static void 1291 smb_node_destroy_audit_buf(smb_node_t *node) 1292 { 1293 if (node->n_audit_buf != NULL) { 1294 kmem_free(node->n_audit_buf, sizeof (smb_audit_buf_node_t)); 1295 node->n_audit_buf = NULL; 1296 } 1297 } 1298 1299 /* 1300 * smb_node_audit 1301 * 1302 * This function saves the calling stack in the audit buffer of the node passed 1303 * in. 1304 */ 1305 static void 1306 smb_node_audit(smb_node_t *node) 1307 { 1308 #ifdef _KERNEL 1309 smb_audit_buf_node_t *abn; 1310 smb_audit_record_node_t *anr; 1311 1312 if (node->n_audit_buf) { 1313 abn = node->n_audit_buf; 1314 anr = abn->anb_records; 1315 anr += abn->anb_index; 1316 abn->anb_index++; 1317 abn->anb_index &= abn->anb_max_index; 1318 anr->anr_refcnt = node->n_refcnt; 1319 anr->anr_depth = getpcstack(anr->anr_stack, 1320 SMB_AUDIT_STACK_DEPTH); 1321 } 1322 #else /* _KERNEL */ 1323 _NOTE(ARGUNUSED(node)) 1324 #endif /* _KERNEL */ 1325 } 1326 1327 static smb_llist_t * 1328 smb_node_get_hash(fsid_t *fsid, smb_attr_t *attr, uint32_t *phashkey) 1329 { 1330 uint32_t hashkey; 1331 1332 hashkey = fsid->val[0] + attr->sa_vattr.va_nodeid; 1333 hashkey += (hashkey >> 24) + (hashkey >> 16) + (hashkey >> 8); 1334 *phashkey = hashkey; 1335 return (&smb_node_hash_table[(hashkey & SMBND_HASH_MASK)]); 1336 } 1337 1338 boolean_t 1339 smb_node_is_file(smb_node_t *node) 1340 { 1341 SMB_NODE_VALID(node); 1342 return (node->vp->v_type == VREG); 1343 } 1344 1345 boolean_t 1346 smb_node_is_dir(smb_node_t *node) 1347 { 1348 SMB_NODE_VALID(node); 1349 return ((node->vp->v_type == VDIR) || 1350 (node->flags & NODE_FLAGS_DFSLINK)); 1351 } 1352 1353 boolean_t 1354 smb_node_is_symlink(smb_node_t *node) 1355 { 1356 SMB_NODE_VALID(node); 1357 return ((node->vp->v_type == VLNK) && 1358 ((node->flags & NODE_FLAGS_REPARSE) == 0)); 1359 } 1360 1361 boolean_t 1362 smb_node_is_dfslink(smb_node_t *node) 1363 { 1364 SMB_NODE_VALID(node); 1365 return ((node->vp->v_type == VLNK) && 1366 (node->flags & NODE_FLAGS_DFSLINK)); 1367 } 1368 1369 boolean_t 1370 smb_node_is_reparse(smb_node_t *node) 1371 { 1372 SMB_NODE_VALID(node); 1373 return ((node->vp->v_type == VLNK) && 1374 (node->flags & NODE_FLAGS_REPARSE)); 1375 } 1376 1377 boolean_t 1378 smb_node_is_vfsroot(smb_node_t *node) 1379 { 1380 SMB_NODE_VALID(node); 1381 return ((node->flags & NODE_FLAGS_VFSROOT) == NODE_FLAGS_VFSROOT); 1382 } 1383 1384 boolean_t 1385 smb_node_is_system(smb_node_t *node) 1386 { 1387 SMB_NODE_VALID(node); 1388 return ((node->flags & NODE_FLAGS_SYSTEM) == NODE_FLAGS_SYSTEM); 1389 } 1390 1391 /* 1392 * smb_node_file_is_readonly 1393 * 1394 * Checks if the file (which node represents) is marked readonly 1395 * in the filesystem. Note that there may be handles open with 1396 * modify rights, and those continue to allow access even after 1397 * the DOS read-only flag has been set in the file system. 1398 */ 1399 boolean_t 1400 smb_node_file_is_readonly(smb_node_t *node) 1401 { 1402 smb_attr_t attr; 1403 1404 if (node == NULL) 1405 return (B_FALSE); /* pipes */ 1406 1407 bzero(&attr, sizeof (smb_attr_t)); 1408 attr.sa_mask = SMB_AT_DOSATTR; 1409 (void) smb_fsop_getattr(NULL, zone_kcred(), node, &attr); 1410 return ((attr.sa_dosattr & FILE_ATTRIBUTE_READONLY) != 0); 1411 } 1412 1413 /* 1414 * smb_node_setattr 1415 * 1416 * The sr may be NULL, for example when closing an ofile. 1417 * The ofile may be NULL, for example when a client request 1418 * specifies the file by pathname. 1419 * 1420 * Returns: errno 1421 * 1422 * Timestamps 1423 * 1424 * Windows and Unix have different models for timestamp updates. 1425 * [MS-FSA 2.1.5.14 Server Requests Setting of File Information] 1426 * 1427 * An open "handle" in Windows can control whether and when 1428 * any timestamp updates happen for that handle. For example, 1429 * timestamps set via some handle are no longer updated by I/O 1430 * operations on that handle. In Unix we don't really have any 1431 * way to avoid the timestamp updates that the file system does. 1432 * Therefore, we need to make some compromises, and simulate the 1433 * more important parts of the Windows file system semantics. 1434 * 1435 * For example, when an SMB client sets file times, set those 1436 * times in the file system (so the change will be visible to 1437 * other clients, at least until they change again) but we also 1438 * make those times "sticky" in our open handle, and reapply 1439 * those times when the handle is closed. That reapply on close 1440 * simulates the Windows behavior where the timestamp updates 1441 * would be discontinued after they were set. These "sticky" 1442 * attributes are returned in any query on the handle where 1443 * they are stored. 1444 * 1445 * Other than the above, the file system layer takes care of the 1446 * normal time stamp updates, such as updating the mtime after a 1447 * write, and ctime after an attribute change. 1448 * 1449 * Dos Attributes are stored persistently, but with a twist: 1450 * In Windows, when you set the "read-only" bit on some file, 1451 * existing writable handles to that file continue to have 1452 * write access. (because access check happens at open) 1453 * If we were to set the read-only bit directly, we would 1454 * cause errors in subsequent writes on any of our open 1455 * (and writable) file handles. So here too, we have to 1456 * simulate the Windows behavior. We keep the read-only 1457 * bit "pending" in the smb_node (so it will be visible in 1458 * any new opens of the file) and apply it on close. 1459 * 1460 * File allocation size is also simulated, and not persistent. 1461 * When the file allocation size is set it is first rounded up 1462 * to block size. If the file size is smaller than the allocation 1463 * size the file is truncated by setting the filesize to allocsz. 1464 */ 1465 int 1466 smb_node_setattr(smb_request_t *sr, smb_node_t *node, 1467 cred_t *cr, smb_ofile_t *of, smb_attr_t *attr) 1468 { 1469 int rc; 1470 uint_t times_mask; 1471 smb_attr_t tmp_attr; 1472 1473 SMB_NODE_VALID(node); 1474 1475 /* set attributes specified in attr */ 1476 if (attr->sa_mask == 0) 1477 return (0); /* nothing to do (caller bug?) */ 1478 1479 /* 1480 * Allocation size and EOF position interact. 1481 * We don't persistently store the allocation size 1482 * but make it look like we do while there are opens. 1483 * Note: We update the caller's attr in the cases 1484 * where they're setting only one of allocsz|size. 1485 */ 1486 switch (attr->sa_mask & (SMB_AT_ALLOCSZ | SMB_AT_SIZE)) { 1487 1488 case SMB_AT_ALLOCSZ: 1489 /* 1490 * Setting the allocation size but not EOF position. 1491 * Get the current EOF in tmp_attr and (if necessary) 1492 * truncate to the (rounded up) allocation size. 1493 * Using kcred here because if we don't have access, 1494 * we want to fail at setattr below and not here. 1495 */ 1496 bzero(&tmp_attr, sizeof (smb_attr_t)); 1497 tmp_attr.sa_mask = SMB_AT_SIZE; 1498 rc = smb_fsop_getattr(NULL, zone_kcred(), node, &tmp_attr); 1499 if (rc != 0) 1500 return (rc); 1501 attr->sa_allocsz = SMB_ALLOCSZ(attr->sa_allocsz); 1502 if (tmp_attr.sa_vattr.va_size > attr->sa_allocsz) { 1503 /* truncate the file to allocsz */ 1504 attr->sa_vattr.va_size = attr->sa_allocsz; 1505 attr->sa_mask |= SMB_AT_SIZE; 1506 } 1507 break; 1508 1509 case SMB_AT_SIZE: 1510 /* 1511 * Setting the EOF position but not allocation size. 1512 * If the new EOF position would be greater than 1513 * the allocation size, increase the latter. 1514 */ 1515 if (node->n_allocsz < attr->sa_vattr.va_size) { 1516 attr->sa_mask |= SMB_AT_ALLOCSZ; 1517 attr->sa_allocsz = 1518 SMB_ALLOCSZ(attr->sa_vattr.va_size); 1519 } 1520 break; 1521 1522 case SMB_AT_ALLOCSZ | SMB_AT_SIZE: 1523 /* 1524 * Setting both. Increase alloc size if needed. 1525 */ 1526 if (attr->sa_allocsz < attr->sa_vattr.va_size) 1527 attr->sa_allocsz = 1528 SMB_ALLOCSZ(attr->sa_vattr.va_size); 1529 break; 1530 1531 default: 1532 break; 1533 } 1534 1535 /* 1536 * If we have an open file, and we set the size, 1537 * then set the "written" flag so that at close, 1538 * we can force an mtime update. 1539 */ 1540 if (of != NULL && (attr->sa_mask & SMB_AT_SIZE) != 0) 1541 of->f_written = B_TRUE; 1542 1543 /* 1544 * When operating on an open file, some settable attributes 1545 * become "sticky" in the open file object until close. 1546 * (see above re. timestamps) 1547 */ 1548 times_mask = attr->sa_mask & SMB_AT_TIMES; 1549 if (of != NULL && times_mask != 0) { 1550 smb_attr_t *pa; 1551 1552 SMB_OFILE_VALID(of); 1553 mutex_enter(&of->f_mutex); 1554 pa = &of->f_pending_attr; 1555 1556 pa->sa_mask |= times_mask; 1557 1558 if (times_mask & SMB_AT_ATIME) 1559 pa->sa_vattr.va_atime = 1560 attr->sa_vattr.va_atime; 1561 if (times_mask & SMB_AT_MTIME) 1562 pa->sa_vattr.va_mtime = 1563 attr->sa_vattr.va_mtime; 1564 if (times_mask & SMB_AT_CTIME) 1565 pa->sa_vattr.va_ctime = 1566 attr->sa_vattr.va_ctime; 1567 if (times_mask & SMB_AT_CRTIME) 1568 pa->sa_crtime = 1569 attr->sa_crtime; 1570 1571 mutex_exit(&of->f_mutex); 1572 /* 1573 * The f_pending_attr times are reapplied in 1574 * smb_ofile_close(). 1575 */ 1576 } 1577 1578 if ((attr->sa_mask & SMB_AT_ALLOCSZ) != 0) { 1579 mutex_enter(&node->n_mutex); 1580 /* 1581 * Simulate n_allocsz persistence only while 1582 * there are opens. See smb_node_getattr 1583 */ 1584 if (node->n_open_count != 0) 1585 node->n_allocsz = attr->sa_allocsz; 1586 mutex_exit(&node->n_mutex); 1587 } 1588 1589 rc = smb_fsop_setattr(sr, cr, node, attr); 1590 if (rc != 0) 1591 return (rc); 1592 1593 if (node->n_dnode != NULL) { 1594 smb_node_notify_change(node->n_dnode, 1595 FILE_ACTION_MODIFIED, node->od_name); 1596 } 1597 1598 return (0); 1599 } 1600 1601 /* 1602 * smb_node_getattr 1603 * 1604 * Get attributes from the file system and apply any smb-specific 1605 * overrides for size, dos attributes and timestamps 1606 * 1607 * When node->n_pending_readonly is set on a node, pretend that 1608 * we've already set this node readonly at the filesystem level. 1609 * We can't actually do that until all writable handles are closed 1610 * or those writable handles would suddenly loose their access. 1611 * 1612 * Returns: errno 1613 */ 1614 int 1615 smb_node_getattr(smb_request_t *sr, smb_node_t *node, cred_t *cr, 1616 smb_ofile_t *of, smb_attr_t *attr) 1617 { 1618 int rc; 1619 uint_t want_mask, pend_mask; 1620 boolean_t isdir; 1621 1622 SMB_NODE_VALID(node); 1623 1624 /* Deal with some interdependencies */ 1625 if (attr->sa_mask & SMB_AT_ALLOCSZ) 1626 attr->sa_mask |= SMB_AT_SIZE; 1627 if (attr->sa_mask & SMB_AT_DOSATTR) 1628 attr->sa_mask |= SMB_AT_TYPE; 1629 1630 rc = smb_fsop_getattr(sr, cr, node, attr); 1631 if (rc != 0) 1632 return (rc); 1633 1634 isdir = smb_node_is_dir(node); 1635 1636 mutex_enter(&node->n_mutex); 1637 1638 if (attr->sa_mask & SMB_AT_DOSATTR) { 1639 if (attr->sa_dosattr == 0) { 1640 attr->sa_dosattr = (isdir) ? 1641 FILE_ATTRIBUTE_DIRECTORY: 1642 FILE_ATTRIBUTE_NORMAL; 1643 } 1644 } 1645 1646 /* 1647 * Also fix-up sa_allocsz, which is not persistent. 1648 * When there are no open files, allocsz is faked. 1649 * While there are open files, we pretend we have a 1650 * persistent allocation size in n_allocsz, and 1651 * keep that up-to-date here, increasing it when 1652 * we see the file size grow past it. 1653 */ 1654 if (attr->sa_mask & SMB_AT_ALLOCSZ) { 1655 if (isdir) { 1656 attr->sa_allocsz = 0; 1657 } else if (node->n_open_count == 0) { 1658 attr->sa_allocsz = 1659 SMB_ALLOCSZ(attr->sa_vattr.va_size); 1660 } else { 1661 if (node->n_allocsz < attr->sa_vattr.va_size) 1662 node->n_allocsz = 1663 SMB_ALLOCSZ(attr->sa_vattr.va_size); 1664 attr->sa_allocsz = node->n_allocsz; 1665 } 1666 } 1667 1668 mutex_exit(&node->n_mutex); 1669 1670 if (isdir) { 1671 attr->sa_vattr.va_size = 0; 1672 attr->sa_vattr.va_nlink = 1; 1673 } 1674 1675 /* 1676 * getattr with an ofile gets any "pending" times that 1677 * might have been previously set via this ofile. 1678 * This is what makes these times "sticky". 1679 */ 1680 want_mask = attr->sa_mask & SMB_AT_TIMES; 1681 if (of != NULL && want_mask != 0) { 1682 smb_attr_t *pa; 1683 1684 SMB_OFILE_VALID(of); 1685 mutex_enter(&of->f_mutex); 1686 pa = &of->f_pending_attr; 1687 1688 pend_mask = pa->sa_mask; 1689 1690 if (want_mask & pend_mask & SMB_AT_ATIME) 1691 attr->sa_vattr.va_atime = 1692 pa->sa_vattr.va_atime; 1693 if (want_mask & pend_mask & SMB_AT_MTIME) 1694 attr->sa_vattr.va_mtime = 1695 pa->sa_vattr.va_mtime; 1696 if (want_mask & pend_mask & SMB_AT_CTIME) 1697 attr->sa_vattr.va_ctime = 1698 pa->sa_vattr.va_ctime; 1699 if (want_mask & pend_mask & SMB_AT_CRTIME) 1700 attr->sa_crtime = 1701 pa->sa_crtime; 1702 1703 mutex_exit(&of->f_mutex); 1704 } 1705 1706 1707 return (0); 1708 } 1709 1710 1711 #ifndef _KERNEL 1712 extern int reparse_vnode_parse(vnode_t *vp, nvlist_t *nvl); 1713 #endif /* _KERNEL */ 1714 1715 /* 1716 * Check to see if the node represents a reparse point. 1717 * If yes, whether the reparse point contains a DFS link. 1718 */ 1719 static void 1720 smb_node_init_reparse(smb_node_t *node, smb_attr_t *attr) 1721 { 1722 nvlist_t *nvl; 1723 nvpair_t *rec; 1724 char *rec_type; 1725 1726 if ((attr->sa_dosattr & FILE_ATTRIBUTE_REPARSE_POINT) == 0) 1727 return; 1728 1729 if ((nvl = reparse_init()) == NULL) 1730 return; 1731 1732 if (reparse_vnode_parse(node->vp, nvl) != 0) { 1733 reparse_free(nvl); 1734 return; 1735 } 1736 1737 node->flags |= NODE_FLAGS_REPARSE; 1738 1739 rec = nvlist_next_nvpair(nvl, NULL); 1740 while (rec != NULL) { 1741 rec_type = nvpair_name(rec); 1742 if ((rec_type != NULL) && 1743 (strcasecmp(rec_type, DFS_REPARSE_SVCTYPE) == 0)) { 1744 node->flags |= NODE_FLAGS_DFSLINK; 1745 break; 1746 } 1747 rec = nvlist_next_nvpair(nvl, rec); 1748 } 1749 1750 reparse_free(nvl); 1751 } 1752 1753 /* 1754 * smb_node_init_system 1755 * 1756 * If the node represents a special system file set NODE_FLAG_SYSTEM. 1757 * System files: 1758 * - any node whose parent dnode has NODE_FLAG_SYSTEM set 1759 * - any node whose associated unnamed stream node (unode) has 1760 * NODE_FLAG_SYSTEM set 1761 * - .$EXTEND at root of share (quota management) 1762 */ 1763 static void 1764 smb_node_init_system(smb_node_t *node) 1765 { 1766 smb_node_t *dnode = node->n_dnode; 1767 smb_node_t *unode = node->n_unode; 1768 1769 if ((dnode) && (dnode->flags & NODE_FLAGS_SYSTEM)) { 1770 node->flags |= NODE_FLAGS_SYSTEM; 1771 return; 1772 } 1773 1774 if ((unode) && (unode->flags & NODE_FLAGS_SYSTEM)) { 1775 node->flags |= NODE_FLAGS_SYSTEM; 1776 return; 1777 } 1778 1779 if ((dnode) && (smb_node_is_vfsroot(node->n_dnode) && 1780 (strcasecmp(node->od_name, ".$EXTEND") == 0))) { 1781 node->flags |= NODE_FLAGS_SYSTEM; 1782 } 1783 } 1784