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