1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 * 25 * Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T. 26 * All rights reserved. 27 */ 28 29 #include <sys/param.h> 30 #include <sys/systm.h> 31 #include <sys/thread.h> 32 #include <sys/t_lock.h> 33 #include <sys/time.h> 34 #include <sys/vnode.h> 35 #include <sys/vfs.h> 36 #include <sys/errno.h> 37 #include <sys/buf.h> 38 #include <sys/stat.h> 39 #include <sys/cred.h> 40 #include <sys/kmem.h> 41 #include <sys/debug.h> 42 #include <sys/vmsystm.h> 43 #include <sys/flock.h> 44 #include <sys/share.h> 45 #include <sys/cmn_err.h> 46 #include <sys/tiuser.h> 47 #include <sys/sysmacros.h> 48 #include <sys/callb.h> 49 #include <sys/acl.h> 50 #include <sys/kstat.h> 51 #include <sys/signal.h> 52 #include <sys/list.h> 53 #include <sys/zone.h> 54 55 #include <netsmb/smb.h> 56 #include <netsmb/smb_conn.h> 57 #include <netsmb/smb_subr.h> 58 59 #include <smbfs/smbfs.h> 60 #include <smbfs/smbfs_node.h> 61 #include <smbfs/smbfs_subr.h> 62 63 #include <vm/hat.h> 64 #include <vm/as.h> 65 #include <vm/page.h> 66 #include <vm/pvn.h> 67 #include <vm/seg.h> 68 #include <vm/seg_map.h> 69 #include <vm/seg_vn.h> 70 71 #define ATTRCACHE_VALID(vp) (gethrtime() < VTOSMB(vp)->r_attrtime) 72 73 static int smbfs_getattr_cache(vnode_t *, smbfattr_t *); 74 static void smbfattr_to_vattr(vnode_t *, smbfattr_t *, vattr_t *); 75 static void smbfattr_to_xvattr(smbfattr_t *, vattr_t *); 76 static int smbfs_getattr_otw(vnode_t *, struct smbfattr *, cred_t *); 77 78 79 /* 80 * The following code provide zone support in order to perform an action 81 * for each smbfs mount in a zone. This is also where we would add 82 * per-zone globals and kernel threads for the smbfs module (since 83 * they must be terminated by the shutdown callback). 84 */ 85 86 struct smi_globals { 87 kmutex_t smg_lock; /* lock protecting smg_list */ 88 list_t smg_list; /* list of SMBFS mounts in zone */ 89 boolean_t smg_destructor_called; 90 }; 91 typedef struct smi_globals smi_globals_t; 92 93 static zone_key_t smi_list_key; 94 95 /* 96 * Attributes caching: 97 * 98 * Attributes are cached in the smbnode in struct vattr form. 99 * There is a time associated with the cached attributes (r_attrtime) 100 * which tells whether the attributes are valid. The time is initialized 101 * to the difference between current time and the modify time of the vnode 102 * when new attributes are cached. This allows the attributes for 103 * files that have changed recently to be timed out sooner than for files 104 * that have not changed for a long time. There are minimum and maximum 105 * timeout values that can be set per mount point. 106 */ 107 108 /* 109 * Helper for _validate_caches 110 */ 111 int 112 smbfs_waitfor_purge_complete(vnode_t *vp) 113 { 114 smbnode_t *np; 115 k_sigset_t smask; 116 117 np = VTOSMB(vp); 118 if (np->r_serial != NULL && np->r_serial != curthread) { 119 mutex_enter(&np->r_statelock); 120 sigintr(&smask, VTOSMI(vp)->smi_flags & SMI_INT); 121 while (np->r_serial != NULL) { 122 if (!cv_wait_sig(&np->r_cv, &np->r_statelock)) { 123 sigunintr(&smask); 124 mutex_exit(&np->r_statelock); 125 return (EINTR); 126 } 127 } 128 sigunintr(&smask); 129 mutex_exit(&np->r_statelock); 130 } 131 return (0); 132 } 133 134 /* 135 * Validate caches by checking cached attributes. If the cached 136 * attributes have timed out, then get new attributes from the server. 137 * As a side affect, this will do cache invalidation if the attributes 138 * have changed. 139 * 140 * If the attributes have not timed out and if there is a cache 141 * invalidation being done by some other thread, then wait until that 142 * thread has completed the cache invalidation. 143 */ 144 int 145 smbfs_validate_caches( 146 struct vnode *vp, 147 cred_t *cr) 148 { 149 struct smbfattr fa; 150 int error; 151 152 if (ATTRCACHE_VALID(vp)) { 153 error = smbfs_waitfor_purge_complete(vp); 154 if (error) 155 return (error); 156 return (0); 157 } 158 159 return (smbfs_getattr_otw(vp, &fa, cr)); 160 } 161 162 /* 163 * Purge all of the various data caches. 164 * 165 * Here NFS also had a flags arg to control what gets flushed. 166 * We only have the page cache, so no flags arg. 167 */ 168 /* ARGSUSED */ 169 void 170 smbfs_purge_caches(struct vnode *vp, cred_t *cr) 171 { 172 173 /* 174 * Here NFS has: Purge the DNLC for this vp, 175 * Clear any readdir state bits, 176 * the readlink response cache, ... 177 */ 178 179 /* 180 * Flush the page cache. 181 */ 182 if (vn_has_cached_data(vp)) { 183 (void) VOP_PUTPAGE(vp, (u_offset_t)0, 0, B_INVAL, cr, NULL); 184 } 185 186 /* 187 * Here NFS has: Flush the readdir response cache. 188 * No readdir cache in smbfs. 189 */ 190 } 191 192 /* 193 * Here NFS has: 194 * nfs_purge_rddir_cache() 195 * nfs3_cache_post_op_attr() 196 * nfs3_cache_post_op_vattr() 197 * nfs3_cache_wcc_data() 198 */ 199 200 /* 201 * Check the attribute cache to see if the new attributes match 202 * those cached. If they do, the various `data' caches are 203 * considered to be good. Otherwise, purge the cached data. 204 */ 205 static void 206 smbfs_cache_check( 207 struct vnode *vp, 208 struct smbfattr *fap, 209 cred_t *cr) 210 { 211 smbnode_t *np; 212 int purge_data = 0; 213 int purge_acl = 0; 214 215 np = VTOSMB(vp); 216 mutex_enter(&np->r_statelock); 217 218 /* 219 * Compare with NFS macro: CACHE_VALID 220 * If the mtime or size has changed, 221 * purge cached data. 222 */ 223 if (np->r_attr.fa_mtime.tv_sec != fap->fa_mtime.tv_sec || 224 np->r_attr.fa_mtime.tv_nsec != fap->fa_mtime.tv_nsec) 225 purge_data = 1; 226 if (np->r_attr.fa_size != fap->fa_size) 227 purge_data = 1; 228 229 if (np->r_attr.fa_ctime.tv_sec != fap->fa_ctime.tv_sec || 230 np->r_attr.fa_ctime.tv_nsec != fap->fa_ctime.tv_nsec) 231 purge_acl = 1; 232 233 if (purge_acl) { 234 np->r_sectime = gethrtime(); 235 } 236 237 mutex_exit(&np->r_statelock); 238 239 if (purge_data) 240 smbfs_purge_caches(vp, cr); 241 } 242 243 /* 244 * Set attributes cache for given vnode using SMB fattr 245 * and update the attribute cache timeout. 246 * 247 * Based on NFS: nfs_attrcache, nfs_attrcache_va 248 */ 249 void 250 smbfs_attrcache_fa(vnode_t *vp, struct smbfattr *fap) 251 { 252 smbnode_t *np; 253 smbmntinfo_t *smi; 254 hrtime_t delta, now; 255 u_offset_t newsize; 256 vtype_t vtype, oldvt; 257 mode_t mode; 258 259 np = VTOSMB(vp); 260 smi = VTOSMI(vp); 261 262 /* 263 * We allow v_type to change, so set that here 264 * (and the mode, which depends on the type). 265 */ 266 if (fap->fa_attr & SMB_FA_DIR) { 267 vtype = VDIR; 268 mode = smi->smi_dmode; 269 } else { 270 vtype = VREG; 271 mode = smi->smi_fmode; 272 } 273 274 mutex_enter(&np->r_statelock); 275 now = gethrtime(); 276 277 /* 278 * Delta is the number of nanoseconds that we will 279 * cache the attributes of the file. It is based on 280 * the number of nanoseconds since the last time that 281 * we detected a change. The assumption is that files 282 * that changed recently are likely to change again. 283 * There is a minimum and a maximum for regular files 284 * and for directories which is enforced though. 285 * 286 * Using the time since last change was detected 287 * eliminates direct comparison or calculation 288 * using mixed client and server times. SMBFS 289 * does not make any assumptions regarding the 290 * client and server clocks being synchronized. 291 */ 292 if (fap->fa_mtime.tv_sec != np->r_attr.fa_mtime.tv_sec || 293 fap->fa_mtime.tv_nsec != np->r_attr.fa_mtime.tv_nsec || 294 fap->fa_size != np->r_attr.fa_size) 295 np->r_mtime = now; 296 297 if ((smi->smi_flags & SMI_NOAC) || (vp->v_flag & VNOCACHE)) 298 delta = 0; 299 else { 300 delta = now - np->r_mtime; 301 if (vtype == VDIR) { 302 if (delta < smi->smi_acdirmin) 303 delta = smi->smi_acdirmin; 304 else if (delta > smi->smi_acdirmax) 305 delta = smi->smi_acdirmax; 306 } else { 307 if (delta < smi->smi_acregmin) 308 delta = smi->smi_acregmin; 309 else if (delta > smi->smi_acregmax) 310 delta = smi->smi_acregmax; 311 } 312 } 313 314 np->r_attrtime = now + delta; 315 np->r_attr = *fap; 316 np->n_mode = mode; 317 oldvt = vp->v_type; 318 vp->v_type = vtype; 319 320 /* 321 * Shall we update r_size? (local notion of size) 322 * 323 * The real criteria for updating r_size should be: 324 * if the file has grown on the server, or if 325 * the client has not modified the file. 326 * 327 * Also deal with the fact that SMB presents 328 * directories as having size=0. Doing that 329 * here and leaving fa_size as returned OtW 330 * avoids fixing the size lots of places. 331 */ 332 newsize = fap->fa_size; 333 if (vtype == VDIR && newsize < DEV_BSIZE) 334 newsize = DEV_BSIZE; 335 336 if (np->r_size != newsize && 337 (!vn_has_cached_data(vp) || 338 (!(np->r_flags & RDIRTY) && np->r_count == 0))) { 339 /* OK to set the size. */ 340 np->r_size = newsize; 341 } 342 343 /* 344 * Here NFS has: 345 * nfs_setswaplike(vp, va); 346 * np->r_flags &= ~RWRITEATTR; 347 * (not needed here) 348 */ 349 350 np->n_flag &= ~NATTRCHANGED; 351 mutex_exit(&np->r_statelock); 352 353 if (oldvt != vtype) { 354 SMBVDEBUG("vtype change %d to %d\n", oldvt, vtype); 355 } 356 } 357 358 /* 359 * Fill in attribute from the cache. 360 * 361 * If valid, copy to *fap and return zero, 362 * otherwise return an error. 363 * 364 * From NFS: nfs_getattr_cache() 365 */ 366 int 367 smbfs_getattr_cache(vnode_t *vp, struct smbfattr *fap) 368 { 369 smbnode_t *np; 370 int error; 371 372 np = VTOSMB(vp); 373 374 mutex_enter(&np->r_statelock); 375 if (gethrtime() >= np->r_attrtime) { 376 /* cache expired */ 377 error = ENOENT; 378 } else { 379 /* cache is valid */ 380 *fap = np->r_attr; 381 error = 0; 382 } 383 mutex_exit(&np->r_statelock); 384 385 return (error); 386 } 387 388 /* 389 * Get attributes over-the-wire and update attributes cache 390 * if no error occurred in the over-the-wire operation. 391 * Return 0 if successful, otherwise error. 392 * From NFS: nfs_getattr_otw 393 */ 394 static int 395 smbfs_getattr_otw(vnode_t *vp, struct smbfattr *fap, cred_t *cr) 396 { 397 struct smbnode *np; 398 struct smb_cred scred; 399 int error; 400 401 np = VTOSMB(vp); 402 403 /* 404 * Here NFS uses the ACL RPC (if smi_flags & SMI_ACL) 405 * With SMB, getting the ACL is a significantly more 406 * expensive operation, so we do that only when asked 407 * for the uid/gid. See smbfsgetattr(). 408 */ 409 410 /* Shared lock for (possible) n_fid use. */ 411 if (smbfs_rw_enter_sig(&np->r_lkserlock, RW_READER, SMBINTR(vp))) 412 return (EINTR); 413 smb_credinit(&scred, cr); 414 415 bzero(fap, sizeof (*fap)); 416 error = smbfs_smb_getfattr(np, fap, &scred); 417 418 smb_credrele(&scred); 419 smbfs_rw_exit(&np->r_lkserlock); 420 421 if (error) { 422 /* Here NFS has: PURGE_STALE_FH(error, vp, cr) */ 423 smbfs_attrcache_remove(np); 424 if (error == ENOENT || error == ENOTDIR) { 425 /* 426 * Getattr failed because the object was 427 * removed or renamed by another client. 428 * Remove any cached attributes under it. 429 */ 430 smbfs_attrcache_prune(np); 431 } 432 return (error); 433 } 434 435 /* 436 * Here NFS has: nfs_cache_fattr(vap, fa, vap, t, cr); 437 * which did: fattr_to_vattr, nfs_attr_cache. 438 * We cache the fattr form, so just do the 439 * cache check and store the attributes. 440 */ 441 smbfs_cache_check(vp, fap, cr); 442 smbfs_attrcache_fa(vp, fap); 443 444 return (0); 445 } 446 447 /* 448 * Return either cached or remote attributes. If we get remote attrs, 449 * use them to check and invalidate caches, then cache the new attributes. 450 * 451 * From NFS: nfsgetattr() 452 */ 453 int 454 smbfsgetattr(vnode_t *vp, struct vattr *vap, cred_t *cr) 455 { 456 struct smbfattr fa; 457 smbmntinfo_t *smi; 458 uint_t mask; 459 int error; 460 461 smi = VTOSMI(vp); 462 463 ASSERT(curproc->p_zone == smi->smi_zone_ref.zref_zone); 464 465 /* 466 * If asked for UID or GID, update n_uid, n_gid. 467 */ 468 mask = AT_ALL; 469 if (vap->va_mask & (AT_UID | AT_GID)) { 470 if (smi->smi_flags & SMI_ACL) 471 (void) smbfs_acl_getids(vp, cr); 472 /* else leave as set in make_smbnode */ 473 } else { 474 mask &= ~(AT_UID | AT_GID); 475 } 476 477 /* 478 * If we've got cached attributes, just use them; 479 * otherwise go to the server to get attributes, 480 * which will update the cache in the process. 481 */ 482 error = smbfs_getattr_cache(vp, &fa); 483 if (error) 484 error = smbfs_getattr_otw(vp, &fa, cr); 485 if (error) 486 return (error); 487 vap->va_mask |= mask; 488 489 /* 490 * Re. client's view of the file size, see: 491 * smbfs_attrcache_fa, smbfs_getattr_otw 492 */ 493 smbfattr_to_vattr(vp, &fa, vap); 494 if (vap->va_mask & AT_XVATTR) 495 smbfattr_to_xvattr(&fa, vap); 496 497 return (0); 498 } 499 500 501 /* 502 * Convert SMB over the wire attributes to vnode form. 503 * Returns 0 for success, error if failed (overflow, etc). 504 * From NFS: nattr_to_vattr() 505 */ 506 void 507 smbfattr_to_vattr(vnode_t *vp, struct smbfattr *fa, struct vattr *vap) 508 { 509 struct smbnode *np = VTOSMB(vp); 510 511 /* 512 * Take type, mode, uid, gid from the smbfs node, 513 * which has have been updated by _getattr_otw. 514 */ 515 vap->va_type = vp->v_type; 516 vap->va_mode = np->n_mode; 517 518 vap->va_uid = np->n_uid; 519 vap->va_gid = np->n_gid; 520 521 vap->va_fsid = vp->v_vfsp->vfs_dev; 522 vap->va_nodeid = np->n_ino; 523 vap->va_nlink = 1; 524 525 /* 526 * Difference from NFS here: We cache attributes as 527 * reported by the server, so r_attr.fa_size is the 528 * server's idea of the file size. This is called 529 * for getattr, so we want to return the client's 530 * idea of the file size. NFS deals with that in 531 * nfsgetattr(), the equivalent of our caller. 532 */ 533 vap->va_size = np->r_size; 534 535 /* 536 * Times. Note, already converted from NT to 537 * Unix form (in the unmarshalling code). 538 */ 539 vap->va_atime = fa->fa_atime; 540 vap->va_mtime = fa->fa_mtime; 541 vap->va_ctime = fa->fa_ctime; 542 543 /* 544 * rdev, blksize, seq are made up. 545 * va_nblocks is 512 byte blocks. 546 */ 547 vap->va_rdev = vp->v_rdev; 548 vap->va_blksize = MAXBSIZE; 549 vap->va_nblocks = (fsblkcnt64_t)btod(np->r_attr.fa_allocsz); 550 vap->va_seq = 0; 551 } 552 553 /* 554 * smbfattr_to_xvattr: like smbfattr_to_vattr but for 555 * Extensible system attributes (PSARC 2007/315) 556 */ 557 static void 558 smbfattr_to_xvattr(struct smbfattr *fa, struct vattr *vap) 559 { 560 xvattr_t *xvap = (xvattr_t *)vap; /* *vap may be xvattr_t */ 561 xoptattr_t *xoap = NULL; 562 563 if ((xoap = xva_getxoptattr(xvap)) == NULL) 564 return; 565 566 if (XVA_ISSET_REQ(xvap, XAT_CREATETIME)) { 567 xoap->xoa_createtime = fa->fa_createtime; 568 XVA_SET_RTN(xvap, XAT_CREATETIME); 569 } 570 571 if (XVA_ISSET_REQ(xvap, XAT_ARCHIVE)) { 572 xoap->xoa_archive = 573 ((fa->fa_attr & SMB_FA_ARCHIVE) != 0); 574 XVA_SET_RTN(xvap, XAT_ARCHIVE); 575 } 576 577 if (XVA_ISSET_REQ(xvap, XAT_SYSTEM)) { 578 xoap->xoa_system = 579 ((fa->fa_attr & SMB_FA_SYSTEM) != 0); 580 XVA_SET_RTN(xvap, XAT_SYSTEM); 581 } 582 583 if (XVA_ISSET_REQ(xvap, XAT_READONLY)) { 584 xoap->xoa_readonly = 585 ((fa->fa_attr & SMB_FA_RDONLY) != 0); 586 XVA_SET_RTN(xvap, XAT_READONLY); 587 } 588 589 if (XVA_ISSET_REQ(xvap, XAT_HIDDEN)) { 590 xoap->xoa_hidden = 591 ((fa->fa_attr & SMB_FA_HIDDEN) != 0); 592 XVA_SET_RTN(xvap, XAT_HIDDEN); 593 } 594 } 595 596 /* 597 * Here NFS has: 598 * nfs_async_... stuff 599 * which we're not using (no async I/O), and: 600 * writerp(), 601 * nfs_putpages() 602 * nfs_invalidate_pages() 603 * which we have in smbfs_vnops.c, and 604 * nfs_printfhandle() 605 * nfs_write_error() 606 * not needed here. 607 */ 608 609 /* 610 * Helper function for smbfs_sync 611 * 612 * Walk the per-zone list of smbfs mounts, calling smbfs_rflush 613 * on each one. This is a little tricky because we need to exit 614 * the list mutex before each _rflush call and then try to resume 615 * where we were in the list after re-entering the mutex. 616 */ 617 void 618 smbfs_flushall(cred_t *cr) 619 { 620 smi_globals_t *smg; 621 smbmntinfo_t *tmp_smi, *cur_smi, *next_smi; 622 623 smg = zone_getspecific(smi_list_key, crgetzone(cr)); 624 ASSERT(smg != NULL); 625 626 mutex_enter(&smg->smg_lock); 627 cur_smi = list_head(&smg->smg_list); 628 if (cur_smi == NULL) { 629 mutex_exit(&smg->smg_lock); 630 return; 631 } 632 VFS_HOLD(cur_smi->smi_vfsp); 633 mutex_exit(&smg->smg_lock); 634 635 flush: 636 smbfs_rflush(cur_smi->smi_vfsp, cr); 637 638 mutex_enter(&smg->smg_lock); 639 /* 640 * Resume after cur_smi if that's still on the list, 641 * otherwise restart at the head. 642 */ 643 for (tmp_smi = list_head(&smg->smg_list); 644 tmp_smi != NULL; 645 tmp_smi = list_next(&smg->smg_list, tmp_smi)) 646 if (tmp_smi == cur_smi) 647 break; 648 if (tmp_smi != NULL) 649 next_smi = list_next(&smg->smg_list, tmp_smi); 650 else 651 next_smi = list_head(&smg->smg_list); 652 653 if (next_smi != NULL) 654 VFS_HOLD(next_smi->smi_vfsp); 655 VFS_RELE(cur_smi->smi_vfsp); 656 657 mutex_exit(&smg->smg_lock); 658 659 if (next_smi != NULL) { 660 cur_smi = next_smi; 661 goto flush; 662 } 663 } 664 665 /* 666 * SMB Client initialization and cleanup. 667 * Much of it is per-zone now. 668 */ 669 670 671 /* ARGSUSED */ 672 static void * 673 smbfs_zone_init(zoneid_t zoneid) 674 { 675 smi_globals_t *smg; 676 677 smg = kmem_alloc(sizeof (*smg), KM_SLEEP); 678 mutex_init(&smg->smg_lock, NULL, MUTEX_DEFAULT, NULL); 679 list_create(&smg->smg_list, sizeof (smbmntinfo_t), 680 offsetof(smbmntinfo_t, smi_zone_node)); 681 smg->smg_destructor_called = B_FALSE; 682 return (smg); 683 } 684 685 /* 686 * Callback routine to tell all SMBFS mounts in the zone to stop creating new 687 * threads. Existing threads should exit. 688 */ 689 /* ARGSUSED */ 690 static void 691 smbfs_zone_shutdown(zoneid_t zoneid, void *data) 692 { 693 smi_globals_t *smg = data; 694 smbmntinfo_t *smi; 695 696 ASSERT(smg != NULL); 697 again: 698 mutex_enter(&smg->smg_lock); 699 for (smi = list_head(&smg->smg_list); smi != NULL; 700 smi = list_next(&smg->smg_list, smi)) { 701 702 /* 703 * If we've done the shutdown work for this FS, skip. 704 * Once we go off the end of the list, we're done. 705 */ 706 if (smi->smi_flags & SMI_DEAD) 707 continue; 708 709 /* 710 * We will do work, so not done. Get a hold on the FS. 711 */ 712 VFS_HOLD(smi->smi_vfsp); 713 714 mutex_enter(&smi->smi_lock); 715 smi->smi_flags |= SMI_DEAD; 716 mutex_exit(&smi->smi_lock); 717 718 /* 719 * Drop lock and release FS, which may change list, then repeat. 720 * We're done when every mi has been done or the list is empty. 721 */ 722 mutex_exit(&smg->smg_lock); 723 VFS_RELE(smi->smi_vfsp); 724 goto again; 725 } 726 mutex_exit(&smg->smg_lock); 727 } 728 729 static void 730 smbfs_zone_free_globals(smi_globals_t *smg) 731 { 732 list_destroy(&smg->smg_list); /* makes sure the list is empty */ 733 mutex_destroy(&smg->smg_lock); 734 kmem_free(smg, sizeof (*smg)); 735 736 } 737 738 /* ARGSUSED */ 739 static void 740 smbfs_zone_destroy(zoneid_t zoneid, void *data) 741 { 742 smi_globals_t *smg = data; 743 744 ASSERT(smg != NULL); 745 mutex_enter(&smg->smg_lock); 746 if (list_head(&smg->smg_list) != NULL) { 747 /* Still waiting for VFS_FREEVFS() */ 748 smg->smg_destructor_called = B_TRUE; 749 mutex_exit(&smg->smg_lock); 750 return; 751 } 752 smbfs_zone_free_globals(smg); 753 } 754 755 /* 756 * Add an SMBFS mount to the per-zone list of SMBFS mounts. 757 */ 758 void 759 smbfs_zonelist_add(smbmntinfo_t *smi) 760 { 761 smi_globals_t *smg; 762 763 smg = zone_getspecific(smi_list_key, smi->smi_zone_ref.zref_zone); 764 mutex_enter(&smg->smg_lock); 765 list_insert_head(&smg->smg_list, smi); 766 mutex_exit(&smg->smg_lock); 767 } 768 769 /* 770 * Remove an SMBFS mount from the per-zone list of SMBFS mounts. 771 */ 772 void 773 smbfs_zonelist_remove(smbmntinfo_t *smi) 774 { 775 smi_globals_t *smg; 776 777 smg = zone_getspecific(smi_list_key, smi->smi_zone_ref.zref_zone); 778 mutex_enter(&smg->smg_lock); 779 list_remove(&smg->smg_list, smi); 780 /* 781 * We can be called asynchronously by VFS_FREEVFS() after the zone 782 * shutdown/destroy callbacks have executed; if so, clean up the zone's 783 * smi_globals. 784 */ 785 if (list_head(&smg->smg_list) == NULL && 786 smg->smg_destructor_called == B_TRUE) { 787 smbfs_zone_free_globals(smg); 788 return; 789 } 790 mutex_exit(&smg->smg_lock); 791 } 792 793 #ifdef lint 794 #define NEED_SMBFS_CALLBACKS 1 795 #endif 796 797 #ifdef NEED_SMBFS_CALLBACKS 798 /* 799 * Call-back hooks for netsmb, in case we want them. 800 * Apple's VFS wants them. We may not need them. 801 */ 802 /*ARGSUSED*/ 803 static void smbfs_dead(smb_share_t *ssp) 804 { 805 /* 806 * Walk the mount list, finding all mounts 807 * using this share... 808 */ 809 } 810 811 /*ARGSUSED*/ 812 static void smbfs_cb_nop(smb_share_t *ss) 813 { 814 /* no-op */ 815 } 816 817 smb_fscb_t smbfs_cb = { 818 .fscb_disconn = smbfs_dead, 819 .fscb_connect = smbfs_cb_nop, 820 .fscb_down = smbfs_cb_nop, 821 .fscb_up = smbfs_cb_nop }; 822 823 #endif /* NEED_SMBFS_CALLBACKS */ 824 825 /* 826 * SMBFS Client initialization routine. This routine should only be called 827 * once. It performs the following tasks: 828 * - Initalize all global locks 829 * - Call sub-initialization routines (localize access to variables) 830 */ 831 int 832 smbfs_clntinit(void) 833 { 834 835 zone_key_create(&smi_list_key, smbfs_zone_init, smbfs_zone_shutdown, 836 smbfs_zone_destroy); 837 #ifdef NEED_SMBFS_CALLBACKS 838 (void) smb_fscb_set(&smbfs_cb); 839 #endif /* NEED_SMBFS_CALLBACKS */ 840 return (0); 841 } 842 843 /* 844 * This routine is called when the modunload is called. This will cleanup 845 * the previously allocated/initialized nodes. 846 */ 847 void 848 smbfs_clntfini(void) 849 { 850 #ifdef NEED_SMBFS_CALLBACKS 851 (void) smb_fscb_set(NULL); 852 #endif /* NEED_SMBFS_CALLBACKS */ 853 (void) zone_key_delete(smi_list_key); 854 } 855