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) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright (c) 2017 by Delphix. All rights reserved. 24 * Copyright 2019 Nexenta by DDN, Inc. All rights reserved. 25 * Copyright 2021-2023 RackTop Systems, Inc. 26 */ 27 28 /* 29 * General Structures Layout 30 * ------------------------- 31 * 32 * This is a simplified diagram showing the relationship between most of the 33 * main structures. 34 * 35 * +-------------------+ 36 * | SMB_SERVER | 37 * +-------------------+ 38 * | 39 * | 40 * v 41 * +-------------------+ +-------------------+ +-------------------+ 42 * | SESSION |<----->| SESSION |......| SESSION | 43 * +-------------------+ +-------------------+ +-------------------+ 44 * | 45 * | 46 * v 47 * +-------------------+ +-------------------+ +-------------------+ 48 * | USER |<----->| USER |......| USER | 49 * +-------------------+ +-------------------+ +-------------------+ 50 * | 51 * | 52 * v 53 * +-------------------+ +-------------------+ +-------------------+ 54 * | TREE |<----->| TREE |......| TREE | 55 * +-------------------+ +-------------------+ +-------------------+ 56 * | | 57 * | | 58 * | v 59 * | +-------+ +-------+ +-------+ 60 * | | OFILE |<----->| OFILE |......| OFILE | 61 * | +-------+ +-------+ +-------+ 62 * | 63 * | 64 * v 65 * +-------+ +------+ +------+ 66 * | ODIR |<----->| ODIR |......| ODIR | 67 * +-------+ +------+ +------+ 68 * 69 * 70 * Module Interface Overview 71 * ------------------------- 72 * 73 * 74 * +===================================+ 75 * | smbd daemon | 76 * +===================================+ 77 * | | ^ 78 * | | | 79 * User | | | 80 * -----------|--------------|----------------|-------------------------------- 81 * Kernel | | | 82 * | | | 83 * | | | 84 * +=========|==============|================|=================+ 85 * | v v | | 86 * | +-----------+ +--------------------+ +------------------+ | 87 * | | IO | | Kernel Door Server | | User Door Servers| | 88 * | | Interface | | Interface | | Interface | | 89 * | +-----------+ +--------------------+ +------------------+ | 90 * | | | ^ ^ | 91 * | v v | | | +=========+ 92 * | +-----------------------------------+ | | | | 93 * | + SMB Server Management (this file) |<------------------| ZFS | 94 * | +-----------------------------------+ | | | | 95 * | | | | Module | 96 * | +-----------------------------------+ | | | | 97 * | + SMB Server Internal Layers |------+ | +=========+ 98 * | +-----------------------------------+ | 99 * | | 100 * | | 101 * +===========================================================+ 102 * 103 * 104 * Server State Machine 105 * -------------------- 106 * | 107 * | T0 108 * | 109 * v 110 * +-----------------------------+ 111 * | SMB_SERVER_STATE_CREATED | 112 * +-----------------------------+ 113 * | 114 * | T1 115 * | 116 * v 117 * +-----------------------------+ 118 * | SMB_SERVER_STATE_CONFIGURED | 119 * +-----------------------------+ 120 * | 121 * | T2 122 * | 123 * v 124 * +-----------------------------+ 125 * | SMB_SERVER_STATE_RUNNING / | 126 * | SMB_SERVER_STATE_STOPPING | 127 * +-----------------------------+ 128 * | 129 * | T3 130 * | 131 * v 132 * +-----------------------------+ 133 * | SMB_SERVER_STATE_DELETING | 134 * +-----------------------------+ 135 * | 136 * | 137 * | 138 * v 139 * 140 * States 141 * ------ 142 * 143 * SMB_SERVER_STATE_CREATED 144 * 145 * This is the state of the server just after creation. 146 * 147 * SMB_SERVER_STATE_CONFIGURED 148 * 149 * The server has been configured. 150 * 151 * SMB_SERVER_STATE_RUNNING 152 * 153 * The server has been started. While in this state the threads listening on 154 * the sockets are started. 155 * 156 * When a client establishes a connection the thread listening dispatches 157 * a task with the new session as an argument. If the dispatch fails the new 158 * session context is destroyed. 159 * 160 * SMB_SERVER_STATE_STOPPING 161 * 162 * The threads listening on the NBT and TCP sockets are being terminated. 163 * 164 * 165 * Transitions 166 * ----------- 167 * 168 * Transition T0 169 * 170 * The daemon smbd triggers its creation by opening the smbsrv device. If 171 * the zone where the daemon lives doesn't have an smb server yet it is 172 * created. 173 * 174 * smb_drv_open() --> smb_server_create() 175 * 176 * Transition T1 177 * 178 * This transition occurs in smb_server_configure(). It is triggered by the 179 * daemon through an Ioctl. 180 * 181 * smb_drv_ioctl(SMB_IOC_CONFIG) --> smb_server_configure() 182 * 183 * Transition T2 184 * 185 * This transition occurs in smb_server_start(). It is triggered by the 186 * daemon through an Ioctl. 187 * 188 * smb_drv_ioctl(SMB_IOC_START) --> smb_server_start() 189 * 190 * Transition T3 191 * 192 * This transition occurs in smb_server_delete(). It is triggered by the 193 * daemon when closing the smbsrv device 194 * 195 * smb_drv_close() --> smb_server_delete() 196 * 197 * Comments 198 * -------- 199 * 200 * This files assumes that there will one SMB server per zone. For now the 201 * smb server works only in global zone. There's nothing in this file preventing 202 * an smb server from being created in a non global zone. That limitation is 203 * enforced in user space. 204 */ 205 206 #include <sys/cmn_err.h> 207 #include <sys/priv.h> 208 #include <sys/zone.h> 209 #include <sys/sysmacros.h> 210 #include <sys/callb.h> 211 #include <sys/class.h> 212 #include <sys/disp.h> 213 #include <netinet/in.h> 214 #include <netinet/in_systm.h> 215 #include <netinet/ip.h> 216 #include <netinet/ip_icmp.h> 217 #include <netinet/ip_var.h> 218 #include <netinet/tcp.h> 219 #include <smbsrv/smb2_kproto.h> 220 #include <smbsrv/string.h> 221 #include <smbsrv/netbios.h> 222 #include <smbsrv/smb_fsops.h> 223 #include <smbsrv/smb_share.h> 224 #include <smbsrv/smb_door.h> 225 #include <smbsrv/smb_kstat.h> 226 227 static void smb_server_kstat_init(smb_server_t *); 228 static void smb_server_kstat_fini(smb_server_t *); 229 static void smb_server_timers(smb_thread_t *, void *); 230 static void smb_server_store_cfg(smb_server_t *, smb_ioc_cfg_t *); 231 static void smb_server_shutdown(smb_server_t *); 232 static int smb_server_fsop_start(smb_server_t *); 233 static void smb_server_fsop_stop(smb_server_t *); 234 static void smb_event_cancel(smb_server_t *, uint32_t); 235 static uint32_t smb_event_alloc_txid(void); 236 237 static void smb_server_disconnect_share(smb_server_t *, const char *); 238 static void smb_server_enum_users(smb_server_t *, smb_svcenum_t *); 239 static void smb_server_enum_trees(smb_server_t *, smb_svcenum_t *); 240 static int smb_server_session_disconnect(smb_server_t *, const char *, 241 const char *); 242 static int smb_server_fclose(smb_server_t *, uint32_t); 243 static int smb_server_kstat_update(kstat_t *, int); 244 static int smb_server_legacy_kstat_update(kstat_t *, int); 245 static void smb_server_listener_init(smb_server_t *, smb_listener_daemon_t *, 246 char *, in_port_t, int); 247 static void smb_server_listener_destroy(smb_listener_daemon_t *); 248 static int smb_server_listener_start(smb_listener_daemon_t *); 249 static void smb_server_listener_stop(smb_listener_daemon_t *); 250 static void smb_server_listener(smb_thread_t *, void *); 251 static void smb_server_receiver(void *); 252 static void smb_server_create_session(smb_listener_daemon_t *, ksocket_t); 253 static void smb_server_destroy_session(smb_session_t *); 254 static uint16_t smb_spool_get_fid(smb_server_t *); 255 static boolean_t smb_spool_lookup_doc_byfid(smb_server_t *, uint16_t, 256 smb_kspooldoc_t *); 257 258 #ifdef _KERNEL 259 int smb_create_process = 1; 260 static void smb_server_delproc(smb_server_t *); 261 static int smb_server_newproc(smb_server_t *); 262 static void smb_server_proc_main(void *); 263 #endif 264 265 /* 266 * How many "buckets" should our hash tables use? On a "real" server, 267 * make them much larger than the number of CPUs we're likely to have. 268 * On "fksmbd" make it smaller so dtrace logs are shorter. 269 * These must be powers of two. 270 */ 271 #ifdef _KERNEL 272 #define DEFAULT_HASH_NBUCKETS 256 /* real server */ 273 #else 274 #define DEFAULT_HASH_NBUCKETS 16 /* for "fksmbd" */ 275 #endif 276 uint32_t SMB_OFILE_HASH_NBUCKETS = DEFAULT_HASH_NBUCKETS; 277 uint32_t SMB_LEASE_HASH_NBUCKETS = DEFAULT_HASH_NBUCKETS; 278 279 int smb_event_debug = 0; 280 281 static smb_llist_t smb_servers; 282 283 /* for smb_server_destroy_session() */ 284 static smb_llist_t smb_server_session_zombies; 285 286 kmem_cache_t *smb_cache_request; 287 kmem_cache_t *smb_cache_session; 288 kmem_cache_t *smb_cache_user; 289 kmem_cache_t *smb_cache_tree; 290 kmem_cache_t *smb_cache_ofile; 291 kmem_cache_t *smb_cache_odir; 292 kmem_cache_t *smb_cache_opipe; 293 kmem_cache_t *smb_cache_event; 294 kmem_cache_t *smb_cache_lock; 295 296 /* 297 * ***************************************************************************** 298 * **************** Functions called from the device interface ***************** 299 * ***************************************************************************** 300 * 301 * These functions typically have to determine the relevant smb server 302 * to which the call applies. 303 */ 304 305 /* 306 * How many zones have an SMB server active? 307 */ 308 int 309 smb_server_get_count(void) 310 { 311 return (smb_llist_get_count(&smb_servers)); 312 } 313 314 /* 315 * smb_server_g_init 316 * 317 * This function must be called from smb_drv_attach(). 318 */ 319 int 320 smb_server_g_init(void) 321 { 322 int rc; 323 324 if ((rc = smb_vop_init()) != 0) 325 goto errout; 326 if ((rc = smb_fem_init()) != 0) 327 goto errout; 328 329 smb_kshare_g_init(); 330 smb_codepage_init(); 331 smb_mbc_init(); /* smb_mbc_cache */ 332 smb_node_init(); /* smb_node_cache, lists */ 333 smb2_lease_init(); 334 335 smb_cache_request = kmem_cache_create("smb_request_cache", 336 sizeof (smb_request_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 337 smb_cache_session = kmem_cache_create("smb_session_cache", 338 sizeof (smb_session_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 339 smb_cache_user = kmem_cache_create("smb_user_cache", 340 sizeof (smb_user_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 341 smb_cache_tree = kmem_cache_create("smb_tree_cache", 342 sizeof (smb_tree_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 343 smb_cache_ofile = kmem_cache_create("smb_ofile_cache", 344 sizeof (smb_ofile_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 345 smb_cache_odir = kmem_cache_create("smb_odir_cache", 346 sizeof (smb_odir_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 347 smb_cache_opipe = kmem_cache_create("smb_opipe_cache", 348 sizeof (smb_opipe_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 349 smb_cache_event = kmem_cache_create("smb_event_cache", 350 sizeof (smb_event_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 351 smb_cache_lock = kmem_cache_create("smb_lock_cache", 352 sizeof (smb_lock_t), 8, NULL, NULL, NULL, NULL, NULL, 0); 353 354 smb_llist_init(); 355 smb_llist_constructor(&smb_servers, sizeof (smb_server_t), 356 offsetof(smb_server_t, sv_lnd)); 357 358 smb_llist_constructor(&smb_server_session_zombies, 359 sizeof (smb_session_t), offsetof(smb_session_t, s_lnd)); 360 361 return (0); 362 363 errout: 364 smb_fem_fini(); 365 smb_vop_fini(); 366 return (rc); 367 } 368 369 /* 370 * smb_server_g_fini 371 * 372 * This function must called from smb_drv_detach(). It will fail if servers 373 * still exist. 374 */ 375 void 376 smb_server_g_fini(void) 377 { 378 379 ASSERT(smb_llist_get_count(&smb_servers) == 0); 380 381 smb_llist_fini(); 382 383 kmem_cache_destroy(smb_cache_request); 384 kmem_cache_destroy(smb_cache_session); 385 kmem_cache_destroy(smb_cache_user); 386 kmem_cache_destroy(smb_cache_tree); 387 kmem_cache_destroy(smb_cache_ofile); 388 kmem_cache_destroy(smb_cache_odir); 389 kmem_cache_destroy(smb_cache_opipe); 390 kmem_cache_destroy(smb_cache_event); 391 kmem_cache_destroy(smb_cache_lock); 392 393 smb2_lease_fini(); 394 smb_node_fini(); 395 smb_mbc_fini(); 396 smb_codepage_fini(); 397 smb_kshare_g_fini(); 398 399 smb_fem_fini(); 400 smb_vop_fini(); 401 402 smb_llist_destructor(&smb_servers); 403 } 404 405 /* 406 * smb_server_create 407 * 408 * Called by driver open 409 * 410 * This function will fail if there's already a server associated with the 411 * caller's zone. 412 * 413 * This object is one-to-one with zones, so we could instead 414 * create/destroy this via zone_key_create callbacks. 415 * See smb_server_delete() for destruction. 416 */ 417 int 418 smb_server_create(void) 419 { 420 zoneid_t zid; 421 smb_server_t *sv; 422 423 zid = getzoneid(); 424 425 smb_llist_enter(&smb_servers, RW_WRITER); 426 sv = smb_llist_head(&smb_servers); 427 while (sv) { 428 SMB_SERVER_VALID(sv); 429 if (sv->sv_zid == zid) { 430 smb_llist_exit(&smb_servers); 431 return (EPERM); 432 } 433 sv = smb_llist_next(&smb_servers, sv); 434 } 435 436 sv = kmem_zalloc(sizeof (smb_server_t), KM_SLEEP); 437 438 sv->sv_magic = SMB_SERVER_MAGIC; 439 sv->sv_state = SMB_SERVER_STATE_CREATED; 440 sv->sv_zid = zid; 441 sv->sv_pid = ddi_get_pid(); 442 sv->sv_proc_state = SMB_THREAD_STATE_EXITED; 443 444 mutex_init(&sv->sv_mutex, NULL, MUTEX_DEFAULT, NULL); 445 cv_init(&sv->sv_cv, NULL, CV_DEFAULT, NULL); 446 cv_init(&sv->sp_info.sp_cv, NULL, CV_DEFAULT, NULL); 447 448 sv->sv_persistid_ht = smb_hash_create(sizeof (smb_ofile_t), 449 offsetof(smb_ofile_t, f_dh_lnd), SMB_OFILE_HASH_NBUCKETS); 450 451 sv->sv_lease_ht = smb_hash_create(sizeof (smb_lease_t), 452 offsetof(smb_lease_t, ls_lnd), SMB_LEASE_HASH_NBUCKETS); 453 454 smb_llist_constructor(&sv->sv_session_list, sizeof (smb_session_t), 455 offsetof(smb_session_t, s_lnd)); 456 457 smb_llist_constructor(&sv->sv_event_list, sizeof (smb_event_t), 458 offsetof(smb_event_t, se_lnd)); 459 460 smb_llist_constructor(&sv->sp_info.sp_list, sizeof (smb_kspooldoc_t), 461 offsetof(smb_kspooldoc_t, sd_lnd)); 462 463 smb_llist_constructor(&sv->sp_info.sp_fidlist, 464 sizeof (smb_spoolfid_t), offsetof(smb_spoolfid_t, sf_lnd)); 465 466 sv->sv_disp_stats1 = kmem_zalloc(SMB_COM_NUM * 467 sizeof (smb_disp_stats_t), KM_SLEEP); 468 469 sv->sv_disp_stats2 = kmem_zalloc(SMB2__NCMDS * 470 sizeof (smb_disp_stats_t), KM_SLEEP); 471 472 smb_thread_init(&sv->si_thread_timers, "smb_timers", 473 smb_server_timers, sv, smbsrv_timer_pri, sv); 474 475 smb_srqueue_init(&sv->sv_srqueue); 476 477 smb_kdoor_init(sv); 478 smb_kshare_init(sv); 479 smb_server_kstat_init(sv); 480 481 smb_threshold_init(&sv->sv_ssetup_ct, SMB_SSETUP_CMD, 482 smb_ssetup_threshold, smb_ssetup_timeout); 483 smb_threshold_init(&sv->sv_tcon_ct, SMB_TCON_CMD, 484 smb_tcon_threshold, smb_tcon_timeout); 485 smb_threshold_init(&sv->sv_opipe_ct, SMB_OPIPE_CMD, 486 smb_opipe_threshold, smb_opipe_timeout); 487 488 smb_llist_insert_tail(&smb_servers, sv); 489 smb_llist_exit(&smb_servers); 490 491 return (0); 492 } 493 494 /* 495 * smb_server_delete 496 * 497 * Called by driver close 498 * 499 * This function will delete the server passed in. It will make sure that all 500 * activity associated that server has ceased before destroying it. 501 */ 502 int 503 smb_server_delete(smb_server_t *sv) 504 { 505 506 mutex_enter(&sv->sv_mutex); 507 switch (sv->sv_state) { 508 case SMB_SERVER_STATE_RUNNING: 509 sv->sv_state = SMB_SERVER_STATE_STOPPING; 510 mutex_exit(&sv->sv_mutex); 511 smb_server_shutdown(sv); 512 mutex_enter(&sv->sv_mutex); 513 cv_broadcast(&sv->sp_info.sp_cv); 514 sv->sv_state = SMB_SERVER_STATE_DELETING; 515 break; 516 case SMB_SERVER_STATE_STOPPING: 517 sv->sv_state = SMB_SERVER_STATE_DELETING; 518 break; 519 case SMB_SERVER_STATE_CONFIGURED: 520 case SMB_SERVER_STATE_CREATED: 521 sv->sv_state = SMB_SERVER_STATE_DELETING; 522 break; 523 default: 524 SMB_SERVER_STATE_VALID(sv->sv_state); 525 mutex_exit(&sv->sv_mutex); 526 smb_server_release(sv); 527 return (ENOTTY); 528 } 529 530 ASSERT(sv->sv_state == SMB_SERVER_STATE_DELETING); 531 532 sv->sv_refcnt--; 533 while (sv->sv_refcnt) 534 cv_wait(&sv->sv_cv, &sv->sv_mutex); 535 536 mutex_exit(&sv->sv_mutex); 537 538 smb_llist_enter(&smb_servers, RW_WRITER); 539 smb_llist_remove(&smb_servers, sv); 540 smb_llist_exit(&smb_servers); 541 542 smb_threshold_fini(&sv->sv_ssetup_ct); 543 smb_threshold_fini(&sv->sv_tcon_ct); 544 smb_threshold_fini(&sv->sv_opipe_ct); 545 546 smb_server_listener_destroy(&sv->sv_nbt_daemon); 547 smb_server_listener_destroy(&sv->sv_tcp_daemon); 548 rw_destroy(&sv->sv_cfg_lock); 549 smb_server_kstat_fini(sv); 550 smb_kshare_fini(sv); 551 smb_kdoor_fini(sv); 552 smb_llist_destructor(&sv->sv_event_list); 553 smb_llist_destructor(&sv->sv_session_list); 554 555 kmem_free(sv->sv_disp_stats1, 556 SMB_COM_NUM * sizeof (smb_disp_stats_t)); 557 558 kmem_free(sv->sv_disp_stats2, 559 SMB2__NCMDS * sizeof (smb_disp_stats_t)); 560 561 smb_srqueue_destroy(&sv->sv_srqueue); 562 smb_thread_destroy(&sv->si_thread_timers); 563 564 mutex_destroy(&sv->sv_mutex); 565 smb_hash_destroy(sv->sv_lease_ht); 566 smb_hash_destroy(sv->sv_persistid_ht); 567 cv_destroy(&sv->sv_cv); 568 sv->sv_magic = 0; 569 kmem_free(sv, sizeof (smb_server_t)); 570 571 return (0); 572 } 573 574 /* 575 * smb_server_configure 576 * 577 * Called via SMB_IOC_CONFIG, for smbd startup or refresh. 578 */ 579 int 580 smb_server_configure(smb_ioc_cfg_t *ioc) 581 { 582 int rc = 0; 583 smb_server_t *sv; 584 585 /* 586 * Reality check negotiation token length vs. #define'd maximum. 587 */ 588 if (ioc->negtok_len > SMB_PI_MAX_NEGTOK) 589 return (EINVAL); 590 591 rc = smb_server_lookup(&sv); 592 if (rc) 593 return (rc); 594 595 mutex_enter(&sv->sv_mutex); 596 switch (sv->sv_state) { 597 case SMB_SERVER_STATE_CREATED: 598 smb_server_store_cfg(sv, ioc); 599 sv->sv_state = SMB_SERVER_STATE_CONFIGURED; 600 break; 601 602 case SMB_SERVER_STATE_CONFIGURED: 603 smb_server_store_cfg(sv, ioc); 604 break; 605 606 case SMB_SERVER_STATE_RUNNING: 607 case SMB_SERVER_STATE_STOPPING: 608 rw_enter(&sv->sv_cfg_lock, RW_WRITER); 609 smb_server_store_cfg(sv, ioc); 610 rw_exit(&sv->sv_cfg_lock); 611 break; 612 613 default: 614 SMB_SERVER_STATE_VALID(sv->sv_state); 615 rc = EFAULT; 616 break; 617 } 618 mutex_exit(&sv->sv_mutex); 619 620 smb_server_release(sv); 621 622 return (rc); 623 } 624 625 /* 626 * smb_server_start 627 * 628 * Called via SMB_IOC_START during smbd startup. 629 * Bring up the activities requried for SMB service. 630 */ 631 int 632 smb_server_start(smb_ioc_start_t *ioc) 633 { 634 int rc = 0; 635 int family; 636 smb_server_t *sv; 637 cred_t *ucr; 638 struct proc *tqproc; 639 640 rc = smb_server_lookup(&sv); 641 if (rc) 642 return (rc); 643 644 mutex_enter(&sv->sv_mutex); 645 switch (sv->sv_state) { 646 case SMB_SERVER_STATE_CONFIGURED: 647 648 #ifdef _KERNEL 649 if (smb_create_process) { 650 rc = smb_server_newproc(sv); 651 if (rc != 0) 652 break; 653 } 654 #endif /* _KERNEL */ 655 656 if ((rc = smb_server_fsop_start(sv)) != 0) 657 break; 658 659 /* 660 * Note: smb_kshare_start needs sv_session. 661 */ 662 sv->sv_session = smb_session_create(NULL, 0, sv, 0); 663 if (sv->sv_session == NULL) { 664 rc = ENOMEM; 665 break; 666 } 667 668 /* 669 * Create a logon on the server session, 670 * used when importing CA shares. 671 */ 672 sv->sv_rootuser = smb_user_new(sv->sv_session); 673 ucr = smb_kcred_create(); 674 rc = smb_user_logon(sv->sv_rootuser, ucr, "", "root", 675 SMB_USER_FLAG_ADMIN, 0, 0); 676 crfree(ucr); 677 ucr = NULL; 678 if (rc != 0) { 679 cmn_err(CE_NOTE, "smb_server_start: " 680 "failed to create root user"); 681 break; 682 } 683 684 if ((rc = smb_kshare_start(sv)) != 0) 685 break; 686 687 /* 688 * Create our taskq's (thread pools) 689 * 690 * NB: the proc passed here has to be a "system" one. 691 * Normally that's p0, or the NGZ eqivalent. 692 * 693 * The notify pool is sized at a quarter the number of 694 * worker threads (instead of another config item). 695 */ 696 tqproc = (sv->sv_proc_p != NULL) ? 697 sv->sv_proc_p : curzone->zone_zsched; 698 699 sv->sv_notify_pool = taskq_create_proc("smb_notify", 700 sv->sv_cfg.skc_maxworkers / 4, smbsrv_notify_pri, 701 sv->sv_cfg.skc_maxworkers / 4, INT_MAX, 702 tqproc, TASKQ_DYNAMIC|TASKQ_THREADS_LWP); 703 704 sv->sv_worker_pool = taskq_create_proc("smb_workers", 705 sv->sv_cfg.skc_maxworkers, smbsrv_worker_pri, 706 sv->sv_cfg.skc_maxworkers, INT_MAX, 707 tqproc, TASKQ_DYNAMIC|TASKQ_THREADS_LWP); 708 709 sv->sv_receiver_pool = taskq_create_proc("smb_receivers", 710 sv->sv_cfg.skc_maxconnections, smbsrv_receive_pri, 711 sv->sv_cfg.skc_maxconnections, INT_MAX, 712 tqproc, TASKQ_DYNAMIC|TASKQ_THREADS_LWP); 713 714 if (sv->sv_notify_pool == NULL || 715 sv->sv_worker_pool == NULL || 716 sv->sv_receiver_pool == NULL) { 717 rc = ENOMEM; 718 break; 719 } 720 721 #ifdef _KERNEL 722 ASSERT(sv->sv_lmshrd == NULL); 723 sv->sv_lmshrd = smb_kshare_door_init(ioc->lmshrd); 724 if (sv->sv_lmshrd == NULL) 725 break; 726 if ((rc = smb_kdoor_open(sv, ioc->udoor)) != 0) { 727 cmn_err(CE_WARN, "Cannot open smbd door"); 728 break; 729 } 730 #else /* _KERNEL */ 731 /* Fake kernel does not use the kshare_door */ 732 fksmb_kdoor_open(sv, ioc->udoor_func); 733 #endif /* _KERNEL */ 734 735 if ((rc = smb_thread_start(&sv->si_thread_timers)) != 0) 736 break; 737 738 family = AF_INET; 739 smb_server_listener_init(sv, &sv->sv_nbt_daemon, 740 "smb_nbt_listener", IPPORT_NETBIOS_SSN, family); 741 if (sv->sv_cfg.skc_ipv6_enable) 742 family = AF_INET6; 743 smb_server_listener_init(sv, &sv->sv_tcp_daemon, 744 "smb_tcp_listener", IPPORT_SMB, family); 745 rc = smb_server_listener_start(&sv->sv_tcp_daemon); 746 if (rc != 0) 747 break; 748 if (sv->sv_cfg.skc_netbios_enable) 749 (void) smb_server_listener_start(&sv->sv_nbt_daemon); 750 751 sv->sv_state = SMB_SERVER_STATE_RUNNING; 752 sv->sv_start_time = gethrtime(); 753 mutex_exit(&sv->sv_mutex); 754 smb_server_release(sv); 755 smb_export_start(sv); 756 return (0); 757 default: 758 SMB_SERVER_STATE_VALID(sv->sv_state); 759 mutex_exit(&sv->sv_mutex); 760 smb_server_release(sv); 761 return (ENOTTY); 762 } 763 764 mutex_exit(&sv->sv_mutex); 765 smb_server_shutdown(sv); 766 smb_server_release(sv); 767 return (rc); 768 } 769 770 /* 771 * An smbd is shutting down. 772 */ 773 int 774 smb_server_stop(void) 775 { 776 smb_server_t *sv; 777 int rc; 778 779 if ((rc = smb_server_lookup(&sv)) != 0) 780 return (rc); 781 782 mutex_enter(&sv->sv_mutex); 783 switch (sv->sv_state) { 784 case SMB_SERVER_STATE_RUNNING: 785 sv->sv_state = SMB_SERVER_STATE_STOPPING; 786 mutex_exit(&sv->sv_mutex); 787 smb_server_shutdown(sv); 788 mutex_enter(&sv->sv_mutex); 789 cv_broadcast(&sv->sp_info.sp_cv); 790 break; 791 default: 792 SMB_SERVER_STATE_VALID(sv->sv_state); 793 break; 794 } 795 mutex_exit(&sv->sv_mutex); 796 797 smb_server_release(sv); 798 return (0); 799 } 800 801 boolean_t 802 smb_server_is_stopping(smb_server_t *sv) 803 { 804 boolean_t status; 805 806 SMB_SERVER_VALID(sv); 807 808 mutex_enter(&sv->sv_mutex); 809 810 switch (sv->sv_state) { 811 case SMB_SERVER_STATE_STOPPING: 812 case SMB_SERVER_STATE_DELETING: 813 status = B_TRUE; 814 break; 815 default: 816 status = B_FALSE; 817 break; 818 } 819 820 mutex_exit(&sv->sv_mutex); 821 return (status); 822 } 823 824 void 825 smb_server_cancel_event(smb_server_t *sv, uint32_t txid) 826 { 827 smb_event_cancel(sv, txid); 828 } 829 830 int 831 smb_server_notify_event(smb_ioc_event_t *ioc) 832 { 833 smb_server_t *sv; 834 int rc; 835 836 if ((rc = smb_server_lookup(&sv)) == 0) { 837 smb_event_notify(sv, ioc->txid); 838 smb_server_release(sv); 839 } 840 841 return (rc); 842 } 843 844 /* 845 * smb_server_spooldoc 846 * 847 * Waits for print file close broadcast. 848 * Gets the head of the fid list, 849 * then searches the spooldoc list and returns 850 * this info via the ioctl to user land. 851 * 852 * rc - 0 success 853 */ 854 855 int 856 smb_server_spooldoc(smb_ioc_spooldoc_t *ioc) 857 { 858 smb_server_t *sv; 859 int rc; 860 smb_kspooldoc_t *spdoc; 861 uint16_t fid; 862 863 if ((rc = smb_server_lookup(&sv)) != 0) 864 return (rc); 865 866 if (sv->sv_cfg.skc_print_enable == 0) { 867 rc = ENOTTY; 868 goto out; 869 } 870 871 mutex_enter(&sv->sv_mutex); 872 for (;;) { 873 if (sv->sv_state != SMB_SERVER_STATE_RUNNING) { 874 rc = ECANCELED; 875 break; 876 } 877 if ((fid = smb_spool_get_fid(sv)) != 0) { 878 rc = 0; 879 break; 880 } 881 if (cv_wait_sig(&sv->sp_info.sp_cv, &sv->sv_mutex) == 0) { 882 rc = EINTR; 883 break; 884 } 885 } 886 mutex_exit(&sv->sv_mutex); 887 if (rc != 0) 888 goto out; 889 890 spdoc = kmem_zalloc(sizeof (*spdoc), KM_SLEEP); 891 if (smb_spool_lookup_doc_byfid(sv, fid, spdoc)) { 892 ioc->spool_num = spdoc->sd_spool_num; 893 ioc->ipaddr = spdoc->sd_ipaddr; 894 (void) strlcpy(ioc->path, spdoc->sd_path, 895 MAXPATHLEN); 896 (void) strlcpy(ioc->username, 897 spdoc->sd_username, MAXNAMELEN); 898 } else { 899 /* Did not find that print job. */ 900 rc = EAGAIN; 901 } 902 kmem_free(spdoc, sizeof (*spdoc)); 903 904 out: 905 smb_server_release(sv); 906 return (rc); 907 } 908 909 int 910 smb_server_set_gmtoff(smb_ioc_gmt_t *ioc) 911 { 912 int rc; 913 smb_server_t *sv; 914 915 if ((rc = smb_server_lookup(&sv)) == 0) { 916 sv->si_gmtoff = ioc->offset; 917 smb_server_release(sv); 918 } 919 920 return (rc); 921 } 922 923 int 924 smb_server_numopen(smb_ioc_opennum_t *ioc) 925 { 926 smb_server_t *sv; 927 int rc; 928 929 if ((rc = smb_server_lookup(&sv)) == 0) { 930 ioc->open_users = sv->sv_users; 931 ioc->open_trees = sv->sv_trees; 932 ioc->open_files = sv->sv_files + sv->sv_pipes; 933 smb_server_release(sv); 934 } 935 return (rc); 936 } 937 938 /* 939 * Enumerate objects within the server. The svcenum provides the 940 * enumeration context, i.e. what the caller want to get back. 941 */ 942 int 943 smb_server_enum(smb_ioc_svcenum_t *ioc) 944 { 945 smb_svcenum_t *svcenum = &ioc->svcenum; 946 smb_server_t *sv; 947 int rc; 948 949 /* 950 * Reality check that the buffer-length insize the enum doesn't 951 * overrun the ioctl's total length. 952 */ 953 if (svcenum->se_buflen + sizeof (*ioc) > ioc->hdr.len) 954 return (EINVAL); 955 956 if ((rc = smb_server_lookup(&sv)) != 0) 957 return (rc); 958 959 svcenum->se_bavail = svcenum->se_buflen; 960 svcenum->se_bused = 0; 961 svcenum->se_nitems = 0; 962 963 switch (svcenum->se_type) { 964 case SMB_SVCENUM_TYPE_USER: 965 smb_server_enum_users(sv, svcenum); 966 break; 967 case SMB_SVCENUM_TYPE_TREE: 968 case SMB_SVCENUM_TYPE_FILE: 969 smb_server_enum_trees(sv, svcenum); 970 break; 971 default: 972 rc = EINVAL; 973 } 974 975 smb_server_release(sv); 976 return (rc); 977 } 978 979 /* 980 * Look for sessions to disconnect by client and user name. 981 */ 982 int 983 smb_server_session_close(smb_ioc_session_t *ioc) 984 { 985 smb_server_t *sv; 986 int cnt; 987 int rc; 988 989 if ((rc = smb_server_lookup(&sv)) != 0) 990 return (rc); 991 992 cnt = smb_server_session_disconnect(sv, ioc->client, ioc->username); 993 994 smb_server_release(sv); 995 996 if (cnt == 0) 997 return (ENOENT); 998 return (0); 999 } 1000 1001 /* 1002 * Close a file by uniqid. 1003 */ 1004 int 1005 smb_server_file_close(smb_ioc_fileid_t *ioc) 1006 { 1007 uint32_t uniqid = ioc->uniqid; 1008 smb_server_t *sv; 1009 int rc; 1010 1011 if ((rc = smb_server_lookup(&sv)) != 0) 1012 return (rc); 1013 1014 rc = smb_server_fclose(sv, uniqid); 1015 1016 smb_server_release(sv); 1017 return (rc); 1018 } 1019 1020 /* 1021 * These functions determine the relevant smb server to which the call apply. 1022 */ 1023 1024 uint32_t 1025 smb_server_get_session_count(smb_server_t *sv) 1026 { 1027 uint32_t counter = 0; 1028 1029 counter = smb_llist_get_count(&sv->sv_session_list); 1030 1031 return (counter); 1032 } 1033 1034 /* 1035 * Gets the smb_node of the specified share path. 1036 * Node is returned held (caller must rele.) 1037 */ 1038 int 1039 smb_server_share_lookup(smb_server_t *sv, const char *shr_path, 1040 smb_node_t **nodepp) 1041 { 1042 smb_request_t *sr; 1043 smb_node_t *fnode = NULL; 1044 smb_node_t *dnode = NULL; 1045 char last_comp[MAXNAMELEN]; 1046 int rc = 0; 1047 1048 ASSERT(shr_path); 1049 1050 mutex_enter(&sv->sv_mutex); 1051 switch (sv->sv_state) { 1052 case SMB_SERVER_STATE_RUNNING: 1053 break; 1054 default: 1055 mutex_exit(&sv->sv_mutex); 1056 return (ENOTACTIVE); 1057 } 1058 mutex_exit(&sv->sv_mutex); 1059 1060 if ((sr = smb_request_alloc(sv->sv_session, 0)) == NULL) { 1061 return (ENOTCONN); 1062 } 1063 sr->user_cr = zone_kcred(); 1064 1065 rc = smb_pathname_reduce(sr, sr->user_cr, shr_path, 1066 NULL, NULL, &dnode, last_comp); 1067 1068 if (rc == 0) { 1069 rc = smb_fsop_lookup(sr, sr->user_cr, SMB_FOLLOW_LINKS, 1070 sv->si_root_smb_node, dnode, last_comp, &fnode); 1071 smb_node_release(dnode); 1072 } 1073 1074 smb_request_free(sr); 1075 1076 if (rc != 0) 1077 return (rc); 1078 1079 ASSERT(fnode->vp && fnode->vp->v_vfsp); 1080 1081 *nodepp = fnode; 1082 1083 return (0); 1084 } 1085 1086 #ifdef _KERNEL 1087 /* 1088 * This is a special interface that will be utilized by ZFS to cause a share to 1089 * be added/removed. 1090 * 1091 * arg is either a lmshare_info_t or share_name from userspace. 1092 * It will need to be copied into the kernel. It is lmshare_info_t 1093 * for add operations and share_name for delete operations. 1094 */ 1095 int 1096 smb_server_share(void *arg, boolean_t add_share) 1097 { 1098 smb_server_t *sv; 1099 int rc; 1100 1101 if ((rc = smb_server_lookup(&sv)) == 0) { 1102 mutex_enter(&sv->sv_mutex); 1103 switch (sv->sv_state) { 1104 case SMB_SERVER_STATE_RUNNING: 1105 mutex_exit(&sv->sv_mutex); 1106 (void) smb_kshare_upcall(sv->sv_lmshrd, arg, add_share); 1107 break; 1108 default: 1109 mutex_exit(&sv->sv_mutex); 1110 break; 1111 } 1112 smb_server_release(sv); 1113 } 1114 1115 return (rc); 1116 } 1117 #endif /* _KERNEL */ 1118 1119 int 1120 smb_server_unshare(const char *sharename) 1121 { 1122 smb_server_t *sv; 1123 int rc; 1124 1125 if ((rc = smb_server_lookup(&sv))) 1126 return (rc); 1127 1128 mutex_enter(&sv->sv_mutex); 1129 switch (sv->sv_state) { 1130 case SMB_SERVER_STATE_RUNNING: 1131 case SMB_SERVER_STATE_STOPPING: 1132 break; 1133 default: 1134 mutex_exit(&sv->sv_mutex); 1135 smb_server_release(sv); 1136 return (ENOTACTIVE); 1137 } 1138 mutex_exit(&sv->sv_mutex); 1139 1140 smb_server_disconnect_share(sv, sharename); 1141 1142 smb_server_release(sv); 1143 return (0); 1144 } 1145 1146 /* 1147 * Disconnect the specified share. 1148 * Typically called when a share has been removed. 1149 */ 1150 static void 1151 smb_server_disconnect_share(smb_server_t *sv, const char *sharename) 1152 { 1153 smb_llist_t *ll; 1154 smb_session_t *session; 1155 1156 ll = &sv->sv_session_list; 1157 smb_llist_enter(ll, RW_READER); 1158 1159 session = smb_llist_head(ll); 1160 while (session) { 1161 SMB_SESSION_VALID(session); 1162 smb_rwx_rwenter(&session->s_lock, RW_READER); 1163 switch (session->s_state) { 1164 case SMB_SESSION_STATE_NEGOTIATED: 1165 smb_rwx_rwexit(&session->s_lock); 1166 smb_session_disconnect_share(session, sharename); 1167 break; 1168 default: 1169 smb_rwx_rwexit(&session->s_lock); 1170 break; 1171 } 1172 session = smb_llist_next(ll, session); 1173 } 1174 1175 smb_llist_exit(ll); 1176 } 1177 1178 #ifdef _KERNEL 1179 1180 /* 1181 * Create a process to own SMB server threads. 1182 */ 1183 static int 1184 smb_server_newproc(smb_server_t *sv) 1185 { 1186 int rc; 1187 1188 mutex_enter(&sv->sv_proc_lock); 1189 if (sv->sv_proc_p != NULL) { 1190 /* restart? re-use proc */ 1191 rc = 0; 1192 goto out; 1193 } 1194 1195 sv->sv_proc_state = SMB_THREAD_STATE_STARTING; 1196 rc = newproc(smb_server_proc_main, (caddr_t)sv, 1197 syscid, smbsrv_base_pri, NULL, 0); 1198 if (rc != 0) { 1199 cmn_err(CE_WARN, "newproc failed, rc=%d", rc); 1200 goto out; 1201 } 1202 1203 /* Rendez-vous with new proc thread. */ 1204 while (sv->sv_proc_state == SMB_THREAD_STATE_STARTING) { 1205 cv_wait(&sv->sv_proc_cv, &sv->sv_proc_lock); 1206 1207 } 1208 if (sv->sv_proc_state != SMB_THREAD_STATE_RUNNING) { 1209 rc = ESRCH; 1210 goto out; 1211 } 1212 ASSERT(sv->sv_proc_p != NULL); 1213 1214 out: 1215 mutex_exit(&sv->sv_proc_lock); 1216 return (rc); 1217 } 1218 1219 /* 1220 * Main thread for the process we create to own SMB server threads. 1221 */ 1222 static void 1223 smb_server_proc_main(void *arg) 1224 { 1225 callb_cpr_t cprinfo; 1226 smb_server_t *sv = arg; 1227 user_t *pu = PTOU(curproc); 1228 zoneid_t zid = getzoneid(); 1229 1230 ASSERT(curproc != &p0); 1231 ASSERT(zid == sv->sv_zid); 1232 1233 (void) strlcpy(pu->u_comm, "smbsrv", sizeof (pu->u_comm)); 1234 (void) snprintf(pu->u_psargs, sizeof (pu->u_psargs), 1235 "smbsrv %d", (int)zid); 1236 1237 CALLB_CPR_INIT(&cprinfo, &sv->sv_proc_lock, callb_generic_cpr, 1238 pu->u_psargs); 1239 1240 mutex_enter(&sv->sv_proc_lock); 1241 ASSERT(sv->sv_proc_state == SMB_THREAD_STATE_STARTING); 1242 1243 sv->sv_proc_p = curproc; 1244 sv->sv_proc_did = curthread->t_did; 1245 1246 sv->sv_proc_state = SMB_THREAD_STATE_RUNNING; 1247 cv_broadcast(&sv->sv_proc_cv); 1248 1249 CALLB_CPR_SAFE_BEGIN(&cprinfo); 1250 while (sv->sv_proc_state == SMB_THREAD_STATE_RUNNING) 1251 cv_wait(&sv->sv_proc_cv, &sv->sv_proc_lock); 1252 CALLB_CPR_SAFE_END(&cprinfo, &sv->sv_proc_lock); 1253 1254 ASSERT(sv->sv_proc_state == SMB_THREAD_STATE_EXITING); 1255 sv->sv_proc_state = SMB_THREAD_STATE_EXITED; 1256 sv->sv_proc_p = NULL; 1257 cv_broadcast(&sv->sv_proc_cv); 1258 CALLB_CPR_EXIT(&cprinfo); /* mutex_exit sv_proc_lock */ 1259 1260 /* Note: lwp_exit() expects p_lock entered. */ 1261 mutex_enter(&curproc->p_lock); 1262 lwp_exit(); 1263 } 1264 1265 /* 1266 * Delete the server proc (if any) 1267 */ 1268 static void 1269 smb_server_delproc(smb_server_t *sv) 1270 { 1271 1272 mutex_enter(&sv->sv_proc_lock); 1273 1274 if (sv->sv_proc_state != SMB_THREAD_STATE_RUNNING) 1275 goto out; 1276 ASSERT(sv->sv_proc_p != NULL); 1277 1278 sv->sv_proc_state = SMB_THREAD_STATE_EXITING; 1279 cv_broadcast(&sv->sv_proc_cv); 1280 1281 /* Rendez-vous with proc thread. */ 1282 while (sv->sv_proc_state == SMB_THREAD_STATE_EXITING) { 1283 cv_wait(&sv->sv_proc_cv, &sv->sv_proc_lock); 1284 1285 } 1286 if (sv->sv_proc_state != SMB_THREAD_STATE_EXITED) { 1287 cmn_err(CE_WARN, "smb_server_delproc, state=%d", 1288 sv->sv_proc_state); 1289 goto out; 1290 } 1291 if (sv->sv_proc_did != 0) { 1292 thread_join(sv->sv_proc_did); 1293 sv->sv_proc_did = 0; 1294 } 1295 1296 out: 1297 mutex_exit(&sv->sv_proc_lock); 1298 } 1299 1300 #endif /* _KERNEL */ 1301 1302 /* 1303 * ***************************************************************************** 1304 * **************** Functions called from the internal layers ****************** 1305 * ***************************************************************************** 1306 * 1307 * These functions are provided the relevant smb server by the caller. 1308 */ 1309 1310 void 1311 smb_server_get_cfg(smb_server_t *sv, smb_kmod_cfg_t *cfg) 1312 { 1313 rw_enter(&sv->sv_cfg_lock, RW_READER); 1314 bcopy(&sv->sv_cfg, cfg, sizeof (*cfg)); 1315 rw_exit(&sv->sv_cfg_lock); 1316 } 1317 1318 /* 1319 * 1320 */ 1321 void 1322 smb_server_inc_nbt_sess(smb_server_t *sv) 1323 { 1324 SMB_SERVER_VALID(sv); 1325 atomic_inc_32(&sv->sv_nbt_sess); 1326 } 1327 1328 void 1329 smb_server_dec_nbt_sess(smb_server_t *sv) 1330 { 1331 SMB_SERVER_VALID(sv); 1332 atomic_dec_32(&sv->sv_nbt_sess); 1333 } 1334 1335 void 1336 smb_server_inc_tcp_sess(smb_server_t *sv) 1337 { 1338 SMB_SERVER_VALID(sv); 1339 atomic_inc_32(&sv->sv_tcp_sess); 1340 } 1341 1342 void 1343 smb_server_dec_tcp_sess(smb_server_t *sv) 1344 { 1345 SMB_SERVER_VALID(sv); 1346 atomic_dec_32(&sv->sv_tcp_sess); 1347 } 1348 1349 void 1350 smb_server_inc_users(smb_server_t *sv) 1351 { 1352 SMB_SERVER_VALID(sv); 1353 atomic_inc_32(&sv->sv_users); 1354 } 1355 1356 void 1357 smb_server_dec_users(smb_server_t *sv) 1358 { 1359 SMB_SERVER_VALID(sv); 1360 atomic_dec_32(&sv->sv_users); 1361 } 1362 1363 void 1364 smb_server_inc_trees(smb_server_t *sv) 1365 { 1366 SMB_SERVER_VALID(sv); 1367 atomic_inc_32(&sv->sv_trees); 1368 } 1369 1370 void 1371 smb_server_dec_trees(smb_server_t *sv) 1372 { 1373 SMB_SERVER_VALID(sv); 1374 atomic_dec_32(&sv->sv_trees); 1375 } 1376 1377 void 1378 smb_server_inc_files(smb_server_t *sv) 1379 { 1380 SMB_SERVER_VALID(sv); 1381 atomic_inc_32(&sv->sv_files); 1382 } 1383 1384 void 1385 smb_server_dec_files(smb_server_t *sv) 1386 { 1387 SMB_SERVER_VALID(sv); 1388 atomic_dec_32(&sv->sv_files); 1389 } 1390 1391 void 1392 smb_server_inc_pipes(smb_server_t *sv) 1393 { 1394 SMB_SERVER_VALID(sv); 1395 atomic_inc_32(&sv->sv_pipes); 1396 } 1397 1398 void 1399 smb_server_dec_pipes(smb_server_t *sv) 1400 { 1401 SMB_SERVER_VALID(sv); 1402 atomic_dec_32(&sv->sv_pipes); 1403 } 1404 1405 void 1406 smb_server_add_rxb(smb_server_t *sv, int64_t value) 1407 { 1408 SMB_SERVER_VALID(sv); 1409 atomic_add_64(&sv->sv_rxb, value); 1410 } 1411 1412 void 1413 smb_server_add_txb(smb_server_t *sv, int64_t value) 1414 { 1415 SMB_SERVER_VALID(sv); 1416 atomic_add_64(&sv->sv_txb, value); 1417 } 1418 1419 void 1420 smb_server_inc_req(smb_server_t *sv) 1421 { 1422 SMB_SERVER_VALID(sv); 1423 atomic_inc_64(&sv->sv_nreq); 1424 } 1425 1426 /* 1427 * ***************************************************************************** 1428 * *************************** Static Functions ******************************** 1429 * ***************************************************************************** 1430 */ 1431 1432 static void 1433 smb_server_timers(smb_thread_t *thread, void *arg) 1434 { 1435 smb_server_t *sv = (smb_server_t *)arg; 1436 1437 ASSERT(sv != NULL); 1438 1439 /* 1440 * This kills old inactive sessions and expired durable 1441 * handles. The session code expects one call per minute. 1442 */ 1443 while (smb_thread_continue_timedwait(thread, 60 /* Seconds */)) { 1444 if (sv->sv_cfg.skc_keepalive != 0) 1445 smb_session_timers(sv); 1446 smb2_durable_timers(sv); 1447 } 1448 } 1449 1450 /* 1451 * smb_server_kstat_init 1452 */ 1453 static void 1454 smb_server_kstat_init(smb_server_t *sv) 1455 { 1456 1457 sv->sv_ksp = kstat_create_zone(SMBSRV_KSTAT_MODULE, 0, 1458 SMBSRV_KSTAT_STATISTICS, SMBSRV_KSTAT_CLASS, KSTAT_TYPE_RAW, 1459 sizeof (smbsrv_kstats_t), 0, sv->sv_zid); 1460 1461 if (sv->sv_ksp != NULL) { 1462 sv->sv_ksp->ks_update = smb_server_kstat_update; 1463 sv->sv_ksp->ks_private = sv; 1464 ((smbsrv_kstats_t *)sv->sv_ksp->ks_data)->ks_start_time = 1465 sv->sv_start_time; 1466 smb_dispatch_stats_init(sv); 1467 smb2_dispatch_stats_init(sv); 1468 kstat_install(sv->sv_ksp); 1469 } else { 1470 cmn_err(CE_WARN, "SMB Server: Statistics unavailable"); 1471 } 1472 1473 sv->sv_legacy_ksp = kstat_create_zone(SMBSRV_KSTAT_MODULE, 0, 1474 SMBSRV_KSTAT_NAME, SMBSRV_KSTAT_CLASS, KSTAT_TYPE_NAMED, 1475 sizeof (smb_server_legacy_kstat_t) / sizeof (kstat_named_t), 1476 0, sv->sv_zid); 1477 1478 if (sv->sv_legacy_ksp != NULL) { 1479 smb_server_legacy_kstat_t *ksd; 1480 1481 ksd = sv->sv_legacy_ksp->ks_data; 1482 1483 (void) strlcpy(ksd->ls_files.name, "open_files", 1484 sizeof (ksd->ls_files.name)); 1485 ksd->ls_files.data_type = KSTAT_DATA_UINT32; 1486 1487 (void) strlcpy(ksd->ls_trees.name, "connections", 1488 sizeof (ksd->ls_trees.name)); 1489 ksd->ls_trees.data_type = KSTAT_DATA_UINT32; 1490 1491 (void) strlcpy(ksd->ls_users.name, "connections", 1492 sizeof (ksd->ls_users.name)); 1493 ksd->ls_users.data_type = KSTAT_DATA_UINT32; 1494 1495 mutex_init(&sv->sv_legacy_ksmtx, NULL, MUTEX_DEFAULT, NULL); 1496 sv->sv_legacy_ksp->ks_lock = &sv->sv_legacy_ksmtx; 1497 sv->sv_legacy_ksp->ks_update = smb_server_legacy_kstat_update; 1498 kstat_install(sv->sv_legacy_ksp); 1499 } 1500 } 1501 1502 /* 1503 * smb_server_kstat_fini 1504 */ 1505 static void 1506 smb_server_kstat_fini(smb_server_t *sv) 1507 { 1508 if (sv->sv_legacy_ksp != NULL) { 1509 kstat_delete(sv->sv_legacy_ksp); 1510 mutex_destroy(&sv->sv_legacy_ksmtx); 1511 sv->sv_legacy_ksp = NULL; 1512 } 1513 1514 if (sv->sv_ksp != NULL) { 1515 kstat_delete(sv->sv_ksp); 1516 sv->sv_ksp = NULL; 1517 smb_dispatch_stats_fini(sv); 1518 smb2_dispatch_stats_fini(sv); 1519 } 1520 } 1521 1522 /* 1523 * Verify the defines in smb_kstat.h used by ks_reqs1 ks_reqs2 1524 */ 1525 CTASSERT(SMBSRV_KS_NREQS1 == SMB_COM_NUM); 1526 CTASSERT(SMBSRV_KS_NREQS2 == SMB2__NCMDS); 1527 1528 /* 1529 * smb_server_kstat_update 1530 */ 1531 static int 1532 smb_server_kstat_update(kstat_t *ksp, int rw) 1533 { 1534 smb_server_t *sv; 1535 smbsrv_kstats_t *ksd; 1536 1537 if (rw == KSTAT_READ) { 1538 sv = ksp->ks_private; 1539 SMB_SERVER_VALID(sv); 1540 ksd = (smbsrv_kstats_t *)ksp->ks_data; 1541 /* 1542 * Counters 1543 */ 1544 ksd->ks_nbt_sess = sv->sv_nbt_sess; 1545 ksd->ks_tcp_sess = sv->sv_tcp_sess; 1546 ksd->ks_users = sv->sv_users; 1547 ksd->ks_trees = sv->sv_trees; 1548 ksd->ks_files = sv->sv_files; 1549 ksd->ks_pipes = sv->sv_pipes; 1550 /* 1551 * Throughput 1552 */ 1553 ksd->ks_txb = sv->sv_txb; 1554 ksd->ks_rxb = sv->sv_rxb; 1555 ksd->ks_nreq = sv->sv_nreq; 1556 /* 1557 * Busyness 1558 */ 1559 ksd->ks_maxreqs = sv->sv_cfg.skc_maxworkers; 1560 smb_srqueue_update(&sv->sv_srqueue, 1561 &ksd->ks_utilization); 1562 /* 1563 * Latency & Throughput of the requests 1564 */ 1565 smb_dispatch_stats_update(sv, ksd->ks_reqs1, 0, SMB_COM_NUM); 1566 smb2_dispatch_stats_update(sv, ksd->ks_reqs2, 0, SMB2__NCMDS); 1567 return (0); 1568 } 1569 if (rw == KSTAT_WRITE) 1570 return (EACCES); 1571 1572 return (EIO); 1573 } 1574 1575 static int 1576 smb_server_legacy_kstat_update(kstat_t *ksp, int rw) 1577 { 1578 smb_server_t *sv; 1579 smb_server_legacy_kstat_t *ksd; 1580 int rc; 1581 1582 switch (rw) { 1583 case KSTAT_WRITE: 1584 rc = EACCES; 1585 break; 1586 case KSTAT_READ: 1587 if (!smb_server_lookup(&sv)) { 1588 ASSERT(MUTEX_HELD(ksp->ks_lock)); 1589 ASSERT(sv->sv_legacy_ksp == ksp); 1590 ksd = (smb_server_legacy_kstat_t *)ksp->ks_data; 1591 ksd->ls_files.value.ui32 = sv->sv_files + sv->sv_pipes; 1592 ksd->ls_trees.value.ui32 = sv->sv_trees; 1593 ksd->ls_users.value.ui32 = sv->sv_users; 1594 smb_server_release(sv); 1595 rc = 0; 1596 break; 1597 } 1598 /* FALLTHROUGH */ 1599 default: 1600 rc = EIO; 1601 break; 1602 } 1603 return (rc); 1604 1605 } 1606 1607 int smb_server_shutdown_wait1 = 15; /* seconds */ 1608 1609 /* 1610 * smb_server_shutdown 1611 */ 1612 static void 1613 smb_server_shutdown(smb_server_t *sv) 1614 { 1615 smb_llist_t *sl = &sv->sv_session_list; 1616 smb_session_t *session; 1617 clock_t time0, time1, time2; 1618 1619 SMB_SERVER_VALID(sv); 1620 1621 /* 1622 * Stop the listeners first, so we can't get any more 1623 * new sessions while we're trying to shut down. 1624 */ 1625 smb_server_listener_stop(&sv->sv_nbt_daemon); 1626 smb_server_listener_stop(&sv->sv_tcp_daemon); 1627 1628 /* 1629 * Disconnect all of the sessions. This causes all the 1630 * smb_server_receiver threads to see a disconnect and 1631 * begin tear-down (in parallel) in smb_session_cancel. 1632 */ 1633 smb_llist_enter(sl, RW_READER); 1634 session = smb_llist_head(sl); 1635 while (session != NULL) { 1636 smb_session_disconnect(session); 1637 session = smb_llist_next(sl, session); 1638 } 1639 smb_llist_exit(sl); 1640 1641 /* 1642 * Wake up any threads we might have blocked. 1643 * Must precede kdoor_close etc. because those will 1644 * wait for such threads to get out. 1645 */ 1646 smb_event_cancel(sv, 0); 1647 smb_threshold_wake_all(&sv->sv_ssetup_ct); 1648 smb_threshold_wake_all(&sv->sv_tcon_ct); 1649 smb_threshold_wake_all(&sv->sv_opipe_ct); 1650 1651 /* 1652 * Wait for the session list to empty. 1653 * (cv_signal in smb_server_destroy_session) 1654 * 1655 * We must wait for all the SMB session readers to finish, or 1656 * we could proceed here while there might be worker threads 1657 * running in any of those sessions. See smb_session_logoff 1658 * for timeouts applied to session tear-down. If this takes 1659 * longer than expected, make some noise, and fire a dtrace 1660 * probe one might use to investigate. 1661 */ 1662 time0 = ddi_get_lbolt(); 1663 time1 = SEC_TO_TICK(smb_server_shutdown_wait1) + time0; 1664 mutex_enter(&sv->sv_mutex); 1665 while (sv->sv_session_list.ll_count != 0) { 1666 if (cv_timedwait(&sv->sv_cv, &sv->sv_mutex, time1) < 0) { 1667 cmn_err(CE_NOTE, "!shutdown waited %d seconds" 1668 " with %d sessions still remaining", 1669 smb_server_shutdown_wait1, 1670 sv->sv_session_list.ll_count); 1671 DTRACE_PROBE1(max__wait, smb_server_t *, sv); 1672 break; 1673 } 1674 } 1675 while (sv->sv_session_list.ll_count != 0) { 1676 cv_wait(&sv->sv_cv, &sv->sv_mutex); 1677 } 1678 mutex_exit(&sv->sv_mutex); 1679 1680 time2 = ddi_get_lbolt(); 1681 if (time2 > time1) { 1682 cmn_err(CE_NOTE, "!shutdown waited %d seconds" 1683 " for all sessions to finish", 1684 (int)TICK_TO_SEC(time2 - time0)); 1685 } 1686 1687 smb_kdoor_close(sv); 1688 #ifdef _KERNEL 1689 smb_kshare_door_fini(sv->sv_lmshrd); 1690 #endif /* _KERNEL */ 1691 sv->sv_lmshrd = NULL; 1692 1693 smb_export_stop(sv); 1694 smb_kshare_stop(sv); 1695 smb_thread_stop(&sv->si_thread_timers); 1696 1697 /* 1698 * Both kshare and the oplock break sub-systems may have 1699 * taskq jobs on the spcial "server" session, until we've 1700 * closed all ofiles and stopped the kshare exporter. 1701 * Now it's safe to destroy the server session, but first 1702 * wait for any requests on it to finish. Note that for 1703 * normal sessions, this happens in smb_session_cancel, 1704 * but that's not called for the server session. 1705 */ 1706 if (sv->sv_rootuser != NULL) { 1707 smb_user_logoff(sv->sv_rootuser); 1708 smb_user_release(sv->sv_rootuser); 1709 sv->sv_rootuser = NULL; 1710 } 1711 if (sv->sv_session != NULL) { 1712 smb_session_cancel_requests(sv->sv_session, NULL, NULL); 1713 smb_slist_wait_for_empty(&sv->sv_session->s_req_list); 1714 1715 /* Just in case import left users and trees */ 1716 smb_session_logoff(sv->sv_session); 1717 1718 smb_session_delete(sv->sv_session); 1719 sv->sv_session = NULL; 1720 } 1721 1722 if (sv->sv_receiver_pool != NULL) { 1723 taskq_destroy(sv->sv_receiver_pool); 1724 sv->sv_receiver_pool = NULL; 1725 } 1726 1727 if (sv->sv_worker_pool != NULL) { 1728 taskq_destroy(sv->sv_worker_pool); 1729 sv->sv_worker_pool = NULL; 1730 } 1731 1732 if (sv->sv_notify_pool != NULL) { 1733 taskq_destroy(sv->sv_notify_pool); 1734 sv->sv_notify_pool = NULL; 1735 } 1736 1737 /* 1738 * Clean out any durable handles. After this we should 1739 * have no ofiles remaining (and no more oplock breaks). 1740 */ 1741 smb2_dh_shutdown(sv); 1742 1743 smb_server_fsop_stop(sv); 1744 1745 #ifdef _KERNEL 1746 if (sv->sv_proc_p != NULL) { 1747 smb_server_delproc(sv); 1748 } 1749 #endif 1750 } 1751 1752 /* 1753 * smb_server_listener_init 1754 * 1755 * Initializes listener contexts. 1756 */ 1757 static void 1758 smb_server_listener_init( 1759 smb_server_t *sv, 1760 smb_listener_daemon_t *ld, 1761 char *name, 1762 in_port_t port, 1763 int family) 1764 { 1765 ASSERT(ld->ld_magic != SMB_LISTENER_MAGIC); 1766 1767 bzero(ld, sizeof (*ld)); 1768 1769 ld->ld_sv = sv; 1770 ld->ld_family = family; 1771 ld->ld_port = port; 1772 1773 if (family == AF_INET) { 1774 ld->ld_sin.sin_family = (uint32_t)family; 1775 ld->ld_sin.sin_port = htons(port); 1776 ld->ld_sin.sin_addr.s_addr = htonl(INADDR_ANY); 1777 } else { 1778 ld->ld_sin6.sin6_family = (uint32_t)family; 1779 ld->ld_sin6.sin6_port = htons(port); 1780 (void) memset(&ld->ld_sin6.sin6_addr.s6_addr, 0, 1781 sizeof (ld->ld_sin6.sin6_addr.s6_addr)); 1782 } 1783 1784 smb_thread_init(&ld->ld_thread, name, smb_server_listener, ld, 1785 smbsrv_listen_pri, sv); 1786 ld->ld_magic = SMB_LISTENER_MAGIC; 1787 } 1788 1789 /* 1790 * smb_server_listener_destroy 1791 * 1792 * Destroyes listener contexts. 1793 */ 1794 static void 1795 smb_server_listener_destroy(smb_listener_daemon_t *ld) 1796 { 1797 /* 1798 * Note that if startup fails early, we can legitimately 1799 * get here with an all-zeros object. 1800 */ 1801 if (ld->ld_magic == 0) 1802 return; 1803 1804 SMB_LISTENER_VALID(ld); 1805 ASSERT(ld->ld_so == NULL); 1806 smb_thread_destroy(&ld->ld_thread); 1807 ld->ld_magic = 0; 1808 } 1809 1810 /* 1811 * smb_server_listener_start 1812 * 1813 * Starts the listener associated with the context passed in. 1814 * 1815 * Return: 0 Success 1816 * not 0 Failure 1817 */ 1818 static int 1819 smb_server_listener_start(smb_listener_daemon_t *ld) 1820 { 1821 int rc; 1822 uint32_t on; 1823 uint32_t off; 1824 1825 SMB_LISTENER_VALID(ld); 1826 1827 if (ld->ld_so != NULL) 1828 return (EINVAL); 1829 1830 ld->ld_so = smb_socreate(ld->ld_family, SOCK_STREAM, 0); 1831 if (ld->ld_so == NULL) { 1832 cmn_err(CE_WARN, "port %d: socket create failed", ld->ld_port); 1833 return (ENOMEM); 1834 } 1835 1836 off = 0; 1837 (void) ksocket_setsockopt(ld->ld_so, SOL_SOCKET, 1838 SO_MAC_EXEMPT, &off, sizeof (off), CRED()); 1839 1840 on = 1; 1841 (void) ksocket_setsockopt(ld->ld_so, SOL_SOCKET, 1842 SO_REUSEADDR, &on, sizeof (on), CRED()); 1843 1844 if (ld->ld_family == AF_INET) { 1845 rc = ksocket_bind(ld->ld_so, 1846 (struct sockaddr *)&ld->ld_sin, 1847 sizeof (ld->ld_sin), CRED()); 1848 } else { 1849 rc = ksocket_bind(ld->ld_so, 1850 (struct sockaddr *)&ld->ld_sin6, 1851 sizeof (ld->ld_sin6), CRED()); 1852 } 1853 1854 if (rc != 0) { 1855 cmn_err(CE_WARN, "port %d: bind failed", ld->ld_port); 1856 return (rc); 1857 } 1858 1859 rc = ksocket_listen(ld->ld_so, 20, CRED()); 1860 if (rc < 0) { 1861 cmn_err(CE_WARN, "port %d: listen failed", ld->ld_port); 1862 return (rc); 1863 } 1864 1865 ksocket_hold(ld->ld_so); 1866 rc = smb_thread_start(&ld->ld_thread); 1867 if (rc != 0) { 1868 ksocket_rele(ld->ld_so); 1869 cmn_err(CE_WARN, "port %d: listener failed to start", 1870 ld->ld_port); 1871 return (rc); 1872 } 1873 return (0); 1874 } 1875 1876 /* 1877 * smb_server_listener_stop 1878 * 1879 * Stops the listener associated with the context passed in. 1880 */ 1881 static void 1882 smb_server_listener_stop(smb_listener_daemon_t *ld) 1883 { 1884 SMB_LISTENER_VALID(ld); 1885 1886 if (ld->ld_so != NULL) { 1887 smb_soshutdown(ld->ld_so); 1888 smb_sodestroy(ld->ld_so); 1889 smb_thread_stop(&ld->ld_thread); 1890 ld->ld_so = NULL; 1891 } 1892 } 1893 1894 /* 1895 * smb_server_listener 1896 * 1897 * Entry point of the listeners. 1898 */ 1899 static void 1900 smb_server_listener(smb_thread_t *thread, void *arg) 1901 { 1902 _NOTE(ARGUNUSED(thread)) 1903 smb_listener_daemon_t *ld; 1904 ksocket_t s_so; 1905 int on; 1906 int txbuf_size; 1907 1908 ld = (smb_listener_daemon_t *)arg; 1909 1910 SMB_LISTENER_VALID(ld); 1911 1912 DTRACE_PROBE1(so__wait__accept, struct sonode *, ld->ld_so); 1913 1914 while (smb_thread_continue_nowait(&ld->ld_thread) && 1915 ld->ld_sv->sv_state != SMB_SERVER_STATE_STOPPING) { 1916 int ret = ksocket_accept(ld->ld_so, NULL, NULL, &s_so, CRED()); 1917 1918 switch (ret) { 1919 case 0: 1920 break; 1921 case ECONNABORTED: 1922 continue; 1923 1924 case EINTR: 1925 case EBADF: 1926 case ENOTSOCK: 1927 /* These are normal during shutdown. Silence. */ 1928 if (ld->ld_sv->sv_state == SMB_SERVER_STATE_STOPPING) 1929 goto out; 1930 /* FALLTHROUGH */ 1931 default: 1932 cmn_err(CE_WARN, 1933 "smb_server_listener: ksocket_accept failed (%d)", 1934 ret); 1935 /* avoid a tight CPU-burn loop here */ 1936 delay(MSEC_TO_TICK(10)); 1937 continue; 1938 } 1939 1940 DTRACE_PROBE1(so__accept, struct sonode *, s_so); 1941 1942 on = 1; 1943 (void) ksocket_setsockopt(s_so, IPPROTO_TCP, TCP_NODELAY, 1944 &on, sizeof (on), CRED()); 1945 1946 on = 1; 1947 (void) ksocket_setsockopt(s_so, SOL_SOCKET, SO_KEEPALIVE, 1948 &on, sizeof (on), CRED()); 1949 1950 txbuf_size = 128*1024; 1951 (void) ksocket_setsockopt(s_so, SOL_SOCKET, SO_SNDBUF, 1952 (const void *)&txbuf_size, sizeof (txbuf_size), CRED()); 1953 1954 /* 1955 * Create a session for this connection. 1956 */ 1957 smb_server_create_session(ld, s_so); 1958 } 1959 out: 1960 ksocket_rele(ld->ld_so); 1961 } 1962 1963 /* 1964 * smb_server_receiver 1965 * 1966 * Entry point of the receiver threads. 1967 * Also does cleanup when socket disconnected. 1968 */ 1969 static void 1970 smb_server_receiver(void *arg) 1971 { 1972 smb_session_t *session; 1973 1974 session = (smb_session_t *)arg; 1975 1976 /* We stay in here until socket disconnect. */ 1977 smb_session_receiver(session); 1978 1979 smb_server_destroy_session(session); 1980 } 1981 1982 /* 1983 * smb_server_lookup 1984 * 1985 * This function finds the server associated with the zone of the 1986 * caller. Note: requires a fix in the dynamic taskq code: 1987 * 1501 taskq_create_proc ... TQ_DYNAMIC puts tasks in p0 1988 */ 1989 int 1990 smb_server_lookup(smb_server_t **psv) 1991 { 1992 zoneid_t zid; 1993 smb_server_t *sv; 1994 1995 zid = getzoneid(); 1996 1997 smb_llist_enter(&smb_servers, RW_READER); 1998 sv = smb_llist_head(&smb_servers); 1999 while (sv) { 2000 SMB_SERVER_VALID(sv); 2001 if (sv->sv_zid == zid) { 2002 mutex_enter(&sv->sv_mutex); 2003 if (sv->sv_state != SMB_SERVER_STATE_DELETING) { 2004 sv->sv_refcnt++; 2005 mutex_exit(&sv->sv_mutex); 2006 smb_llist_exit(&smb_servers); 2007 *psv = sv; 2008 return (0); 2009 } 2010 mutex_exit(&sv->sv_mutex); 2011 break; 2012 } 2013 sv = smb_llist_next(&smb_servers, sv); 2014 } 2015 smb_llist_exit(&smb_servers); 2016 return (EPERM); 2017 } 2018 2019 /* 2020 * smb_server_release 2021 * 2022 * This function decrements the reference count of the server and signals its 2023 * condition variable if the state of the server is SMB_SERVER_STATE_DELETING. 2024 */ 2025 void 2026 smb_server_release(smb_server_t *sv) 2027 { 2028 SMB_SERVER_VALID(sv); 2029 2030 mutex_enter(&sv->sv_mutex); 2031 ASSERT(sv->sv_refcnt); 2032 sv->sv_refcnt--; 2033 if ((sv->sv_refcnt == 0) && (sv->sv_state == SMB_SERVER_STATE_DELETING)) 2034 cv_signal(&sv->sv_cv); 2035 mutex_exit(&sv->sv_mutex); 2036 } 2037 2038 /* 2039 * smb_server_lookup_user 2040 * 2041 * Find an smb_user by its user_id 2042 * Optional ssn_id (if non-zero) restricts search to a specific session. 2043 * 2044 * Returns smb_user_t * held. Caller must smb_user_rele(user) 2045 * Returns NULL if not found. 2046 */ 2047 smb_user_t * 2048 smb_server_lookup_user(smb_server_t *sv, uint64_t ssn_id, uint64_t user_id) 2049 { 2050 smb_llist_t *slist = &sv->sv_session_list; 2051 smb_session_t *sn; 2052 smb_user_t *user = NULL; 2053 2054 smb_llist_enter(slist, RW_READER); 2055 2056 for (sn = smb_llist_head(slist); 2057 sn != NULL && user == NULL; 2058 sn = smb_llist_next(slist, sn)) { 2059 SMB_SESSION_VALID(sn); 2060 2061 if (ssn_id != 0 && ssn_id != sn->s_kid) 2062 continue; 2063 if (sn->s_state != SMB_SESSION_STATE_NEGOTIATED) 2064 continue; 2065 2066 user = smb_session_lookup_ssnid(sn, user_id); 2067 } 2068 smb_llist_exit(slist); 2069 2070 return (user); 2071 } 2072 2073 /* 2074 * Enumerate the users associated with a session list. 2075 */ 2076 static void 2077 smb_server_enum_users(smb_server_t *sv, smb_svcenum_t *svcenum) 2078 { 2079 smb_llist_t *ll = &sv->sv_session_list; 2080 smb_session_t *sn; 2081 smb_llist_t *ulist; 2082 smb_user_t *user; 2083 int rc = 0; 2084 2085 smb_llist_enter(ll, RW_READER); 2086 sn = smb_llist_head(ll); 2087 2088 while (sn != NULL) { 2089 SMB_SESSION_VALID(sn); 2090 ulist = &sn->s_user_list; 2091 smb_llist_enter(ulist, RW_READER); 2092 user = smb_llist_head(ulist); 2093 2094 while (user != NULL) { 2095 if (smb_user_hold(user)) { 2096 rc = smb_user_enum(user, svcenum); 2097 smb_user_release(user); 2098 if (rc != 0) 2099 break; 2100 } 2101 2102 user = smb_llist_next(ulist, user); 2103 } 2104 2105 smb_llist_exit(ulist); 2106 2107 if (rc != 0) 2108 break; 2109 2110 sn = smb_llist_next(ll, sn); 2111 } 2112 2113 smb_llist_exit(ll); 2114 } 2115 2116 /* 2117 * Enumerate the trees/files associated with a session list. 2118 */ 2119 static void 2120 smb_server_enum_trees(smb_server_t *sv, smb_svcenum_t *svcenum) 2121 { 2122 smb_llist_t *ll = &sv->sv_session_list; 2123 smb_session_t *sn; 2124 smb_llist_t *tlist; 2125 smb_tree_t *tree; 2126 int rc = 0; 2127 2128 smb_llist_enter(ll, RW_READER); 2129 sn = smb_llist_head(ll); 2130 2131 while (sn != NULL) { 2132 SMB_SESSION_VALID(sn); 2133 tlist = &sn->s_tree_list; 2134 smb_llist_enter(tlist, RW_READER); 2135 tree = smb_llist_head(tlist); 2136 2137 while (tree != NULL) { 2138 if (smb_tree_hold(tree)) { 2139 rc = smb_tree_enum(tree, svcenum); 2140 smb_tree_release(tree); 2141 if (rc != 0) 2142 break; 2143 } 2144 2145 tree = smb_llist_next(tlist, tree); 2146 } 2147 2148 smb_llist_exit(tlist); 2149 2150 if (rc != 0) 2151 break; 2152 2153 sn = smb_llist_next(ll, sn); 2154 } 2155 2156 smb_llist_exit(ll); 2157 } 2158 2159 /* 2160 * Disconnect sessions associated with the specified client and username. 2161 * Empty strings are treated as wildcards. 2162 */ 2163 static int 2164 smb_server_session_disconnect(smb_server_t *sv, 2165 const char *client, const char *name) 2166 { 2167 smb_llist_t *ll = &sv->sv_session_list; 2168 smb_session_t *sn; 2169 smb_llist_t *ulist; 2170 smb_user_t *user; 2171 int count = 0; 2172 2173 smb_llist_enter(ll, RW_READER); 2174 2175 for (sn = smb_llist_head(ll); 2176 sn != NULL; 2177 sn = smb_llist_next(ll, sn)) { 2178 SMB_SESSION_VALID(sn); 2179 2180 if (*client != '\0' && !smb_session_isclient(sn, client)) 2181 continue; 2182 2183 ulist = &sn->s_user_list; 2184 smb_llist_enter(ulist, RW_READER); 2185 2186 for (user = smb_llist_head(ulist); 2187 user != NULL; 2188 user = smb_llist_next(ulist, user)) { 2189 2190 if (smb_user_hold(user)) { 2191 2192 if (*name == '\0' || 2193 smb_user_namecmp(user, name)) { 2194 smb_user_logoff(user); 2195 count++; 2196 } 2197 2198 smb_user_release(user); 2199 } 2200 } 2201 2202 smb_llist_exit(ulist); 2203 } 2204 2205 smb_llist_exit(ll); 2206 return (count); 2207 } 2208 2209 /* 2210 * Close a file by its unique id. 2211 */ 2212 static int 2213 smb_server_fclose(smb_server_t *sv, uint32_t uniqid) 2214 { 2215 smb_llist_t *ll; 2216 smb_session_t *sn; 2217 smb_llist_t *tlist; 2218 smb_tree_t *tree; 2219 int rc = ENOENT; 2220 2221 ll = &sv->sv_session_list; 2222 smb_llist_enter(ll, RW_READER); 2223 sn = smb_llist_head(ll); 2224 2225 while ((sn != NULL) && (rc == ENOENT)) { 2226 SMB_SESSION_VALID(sn); 2227 tlist = &sn->s_tree_list; 2228 smb_llist_enter(tlist, RW_READER); 2229 tree = smb_llist_head(tlist); 2230 2231 while ((tree != NULL) && (rc == ENOENT)) { 2232 if (smb_tree_hold(tree)) { 2233 rc = smb_tree_fclose(tree, uniqid); 2234 smb_tree_release(tree); 2235 } 2236 2237 tree = smb_llist_next(tlist, tree); 2238 } 2239 2240 smb_llist_exit(tlist); 2241 sn = smb_llist_next(ll, sn); 2242 } 2243 2244 smb_llist_exit(ll); 2245 return (rc); 2246 } 2247 2248 /* 2249 * This is used by SMB2 session setup to logoff a previous session, 2250 * so it can force a logoff that we haven't noticed yet. 2251 * This is not called frequently, so we just walk the list of 2252 * connections searching for the user. 2253 * 2254 * Note that this must wait for any durable handles (ofiles) 2255 * owned by this user to become "orphaned", so that a reconnect 2256 * that may immediately follow can find and use such ofiles. 2257 */ 2258 void 2259 smb_server_logoff_ssnid(smb_request_t *sr, uint64_t ssnid) 2260 { 2261 smb_server_t *sv = sr->sr_server; 2262 smb_llist_t *sess_list; 2263 smb_session_t *sess; 2264 smb_user_t *user = NULL; 2265 boolean_t do_logoff = B_FALSE; 2266 2267 SMB_SERVER_VALID(sv); 2268 2269 if (sv->sv_state != SMB_SERVER_STATE_RUNNING) 2270 return; 2271 2272 sess_list = &sv->sv_session_list; 2273 smb_llist_enter(sess_list, RW_READER); 2274 2275 for (sess = smb_llist_head(sess_list); 2276 sess != NULL; 2277 sess = smb_llist_next(sess_list, sess)) { 2278 2279 SMB_SESSION_VALID(sess); 2280 2281 if (sess->dialect < SMB_VERS_2_BASE) 2282 continue; 2283 2284 switch (sess->s_state) { 2285 case SMB_SESSION_STATE_NEGOTIATED: 2286 case SMB_SESSION_STATE_TERMINATED: 2287 case SMB_SESSION_STATE_DISCONNECTED: 2288 break; 2289 default: 2290 continue; 2291 } 2292 2293 /* 2294 * Normal situation is to find a LOGGED_ON user. 2295 */ 2296 user = smb_session_lookup_uid_st(sess, ssnid, 0, 2297 SMB_USER_STATE_LOGGED_ON); 2298 if (user != NULL) { 2299 if (smb_is_same_user(user->u_cred, sr->user_cr)) { 2300 do_logoff = B_TRUE; 2301 break; 2302 } 2303 smb_user_release(user); 2304 user = NULL; 2305 } 2306 2307 /* 2308 * If we raced with disconnect, may find LOGGING_OFF, 2309 * in which case we want to just wait for it. 2310 */ 2311 user = smb_session_lookup_uid_st(sess, ssnid, 0, 2312 SMB_USER_STATE_LOGGING_OFF); 2313 if (user != NULL) { 2314 if (smb_is_same_user(user->u_cred, sr->user_cr)) 2315 break; 2316 smb_user_release(user); 2317 user = NULL; 2318 } 2319 } 2320 2321 smb_llist_exit(sess_list); 2322 2323 /* 2324 * Note that smb_user_logoff() can block for a while if 2325 * smb_session_disconnect_owned_trees, smb_ofile_close_all 2326 * ends up blocked on locks held by running requests. 2327 * Do that while not holding the session list rwlock. 2328 */ 2329 if (user != NULL) { 2330 if (do_logoff) { 2331 /* Treat this as if we lost the connection */ 2332 user->preserve_opens = SMB2_DH_PRESERVE_SOME; 2333 smb_user_logoff(user); 2334 } 2335 2336 /* 2337 * Wait for durable handles to be orphaned. 2338 * Note: not holding the sess list rwlock. 2339 */ 2340 smb_user_wait_trees(user); 2341 2342 /* 2343 * Could be doing the last release on a user below, 2344 * which can leave work on the delete queues for 2345 * s_user_list or s_tree_list so flush those. 2346 * Must hold the session list after the user release 2347 * so that the session can't go away while we flush. 2348 */ 2349 smb_llist_enter(sess_list, RW_READER); 2350 2351 sess = user->u_session; 2352 smb_user_release(user); 2353 2354 smb_llist_flush(&sess->s_tree_list); 2355 smb_llist_flush(&sess->s_user_list); 2356 2357 smb_llist_exit(sess_list); 2358 } 2359 } 2360 2361 /* See also: libsmb smb_kmod_setcfg */ 2362 static void 2363 smb_server_store_cfg(smb_server_t *sv, smb_ioc_cfg_t *ioc) 2364 { 2365 if (ioc->maxconnections == 0) 2366 ioc->maxconnections = 0xFFFFFFFF; 2367 2368 if (ioc->encrypt == SMB_CONFIG_REQUIRED && 2369 ioc->max_protocol < SMB_VERS_3_0) { 2370 cmn_err(CE_WARN, "Server set to require encryption; " 2371 "forcing max_protocol to 3.0"); 2372 ioc->max_protocol = SMB_VERS_3_0; 2373 } 2374 sv->sv_cfg.skc_maxworkers = ioc->maxworkers; 2375 sv->sv_cfg.skc_maxconnections = ioc->maxconnections; 2376 sv->sv_cfg.skc_keepalive = ioc->keepalive; 2377 sv->sv_cfg.skc_restrict_anon = ioc->restrict_anon; 2378 sv->sv_cfg.skc_signing_enable = ioc->signing_enable; 2379 sv->sv_cfg.skc_signing_required = ioc->signing_required; 2380 sv->sv_cfg.skc_oplock_enable = ioc->oplock_enable; 2381 sv->sv_cfg.skc_sync_enable = ioc->sync_enable; 2382 sv->sv_cfg.skc_secmode = ioc->secmode; 2383 sv->sv_cfg.skc_netbios_enable = ioc->netbios_enable; 2384 sv->sv_cfg.skc_ipv6_enable = ioc->ipv6_enable; 2385 sv->sv_cfg.skc_print_enable = ioc->print_enable; 2386 sv->sv_cfg.skc_traverse_mounts = ioc->traverse_mounts; 2387 sv->sv_cfg.skc_short_names = ioc->short_names; 2388 sv->sv_cfg.skc_max_protocol = ioc->max_protocol; 2389 sv->sv_cfg.skc_min_protocol = ioc->min_protocol; 2390 sv->sv_cfg.skc_encrypt = ioc->encrypt; 2391 sv->sv_cfg.skc_encrypt_ciphers = ioc->encrypt_ciphers; 2392 sv->sv_cfg.skc_execflags = ioc->exec_flags; 2393 sv->sv_cfg.skc_negtok_len = ioc->negtok_len; 2394 sv->sv_cfg.skc_max_opens = ioc->max_opens; 2395 sv->sv_cfg.skc_version = ioc->version; 2396 sv->sv_cfg.skc_initial_credits = ioc->initial_credits; 2397 sv->sv_cfg.skc_maximum_credits = ioc->maximum_credits; 2398 2399 (void) memcpy(sv->sv_cfg.skc_machine_uuid, ioc->machine_uuid, 2400 sizeof (uuid_t)); 2401 (void) memcpy(sv->sv_cfg.skc_negtok, ioc->negtok, 2402 sizeof (sv->sv_cfg.skc_negtok)); 2403 (void) memcpy(sv->sv_cfg.skc_native_os, ioc->native_os, 2404 sizeof (sv->sv_cfg.skc_native_os)); 2405 (void) memcpy(sv->sv_cfg.skc_native_lm, ioc->native_lm, 2406 sizeof (sv->sv_cfg.skc_native_lm)); 2407 2408 (void) strlcpy(sv->sv_cfg.skc_nbdomain, ioc->nbdomain, 2409 sizeof (sv->sv_cfg.skc_nbdomain)); 2410 (void) strlcpy(sv->sv_cfg.skc_fqdn, ioc->fqdn, 2411 sizeof (sv->sv_cfg.skc_fqdn)); 2412 (void) strlcpy(sv->sv_cfg.skc_hostname, ioc->hostname, 2413 sizeof (sv->sv_cfg.skc_hostname)); 2414 (void) strlcpy(sv->sv_cfg.skc_system_comment, ioc->system_comment, 2415 sizeof (sv->sv_cfg.skc_system_comment)); 2416 } 2417 2418 static int 2419 smb_server_fsop_start(smb_server_t *sv) 2420 { 2421 int error; 2422 2423 error = smb_node_root_init(sv, &sv->si_root_smb_node); 2424 if (error != 0) 2425 sv->si_root_smb_node = NULL; 2426 2427 return (error); 2428 } 2429 2430 static void 2431 smb_server_fsop_stop(smb_server_t *sv) 2432 { 2433 if (sv->si_root_smb_node != NULL) { 2434 smb_node_release(sv->si_root_smb_node); 2435 sv->si_root_smb_node = NULL; 2436 } 2437 } 2438 2439 smb_event_t * 2440 smb_event_create(smb_server_t *sv, int timeout) 2441 { 2442 smb_event_t *event; 2443 2444 if (smb_server_is_stopping(sv)) 2445 return (NULL); 2446 2447 event = kmem_cache_alloc(smb_cache_event, KM_SLEEP); 2448 2449 bzero(event, sizeof (smb_event_t)); 2450 mutex_init(&event->se_mutex, NULL, MUTEX_DEFAULT, NULL); 2451 cv_init(&event->se_cv, NULL, CV_DEFAULT, NULL); 2452 event->se_magic = SMB_EVENT_MAGIC; 2453 event->se_txid = smb_event_alloc_txid(); 2454 event->se_server = sv; 2455 event->se_timeout = timeout; 2456 2457 smb_llist_enter(&sv->sv_event_list, RW_WRITER); 2458 smb_llist_insert_tail(&sv->sv_event_list, event); 2459 smb_llist_exit(&sv->sv_event_list); 2460 2461 return (event); 2462 } 2463 2464 void 2465 smb_event_destroy(smb_event_t *event) 2466 { 2467 smb_server_t *sv; 2468 2469 if (event == NULL) 2470 return; 2471 2472 SMB_EVENT_VALID(event); 2473 ASSERT(event->se_waittime == 0); 2474 sv = event->se_server; 2475 SMB_SERVER_VALID(sv); 2476 2477 smb_llist_enter(&sv->sv_event_list, RW_WRITER); 2478 smb_llist_remove(&sv->sv_event_list, event); 2479 smb_llist_exit(&sv->sv_event_list); 2480 2481 event->se_magic = (uint32_t)~SMB_EVENT_MAGIC; 2482 cv_destroy(&event->se_cv); 2483 mutex_destroy(&event->se_mutex); 2484 2485 kmem_cache_free(smb_cache_event, event); 2486 } 2487 2488 /* 2489 * Get the txid for the specified event. 2490 */ 2491 uint32_t 2492 smb_event_txid(smb_event_t *event) 2493 { 2494 if (event != NULL) { 2495 SMB_EVENT_VALID(event); 2496 return (event->se_txid); 2497 } 2498 2499 cmn_err(CE_NOTE, "smb_event_txid failed"); 2500 return ((uint32_t)-1); 2501 } 2502 2503 /* 2504 * Wait for event notification. 2505 */ 2506 int 2507 smb_event_wait(smb_event_t *event) 2508 { 2509 int seconds = 1; 2510 int ticks; 2511 int err; 2512 2513 if (event == NULL) 2514 return (EINVAL); 2515 2516 SMB_EVENT_VALID(event); 2517 2518 mutex_enter(&event->se_mutex); 2519 event->se_waittime = 1; 2520 event->se_errno = 0; 2521 2522 while (!(event->se_notified)) { 2523 if (smb_event_debug && ((event->se_waittime % 30) == 0)) 2524 cmn_err(CE_NOTE, "smb_event_wait[%d] (%d sec)", 2525 event->se_txid, event->se_waittime); 2526 2527 if (event->se_errno != 0) 2528 break; 2529 2530 if (event->se_waittime > event->se_timeout) { 2531 event->se_errno = ETIME; 2532 break; 2533 } 2534 2535 ticks = SEC_TO_TICK(seconds); 2536 (void) cv_reltimedwait(&event->se_cv, 2537 &event->se_mutex, (clock_t)ticks, TR_CLOCK_TICK); 2538 ++event->se_waittime; 2539 } 2540 2541 err = event->se_errno; 2542 event->se_waittime = 0; 2543 event->se_notified = B_FALSE; 2544 cv_signal(&event->se_cv); 2545 mutex_exit(&event->se_mutex); 2546 return (err); 2547 } 2548 2549 /* 2550 * If txid is non-zero, cancel the specified event. 2551 * Otherwise, cancel all events. 2552 */ 2553 static void 2554 smb_event_cancel(smb_server_t *sv, uint32_t txid) 2555 { 2556 smb_event_t *event; 2557 smb_llist_t *event_list; 2558 2559 SMB_SERVER_VALID(sv); 2560 2561 event_list = &sv->sv_event_list; 2562 smb_llist_enter(event_list, RW_WRITER); 2563 2564 event = smb_llist_head(event_list); 2565 while (event) { 2566 SMB_EVENT_VALID(event); 2567 2568 if (txid == 0 || event->se_txid == txid) { 2569 mutex_enter(&event->se_mutex); 2570 event->se_errno = ECANCELED; 2571 event->se_notified = B_TRUE; 2572 cv_signal(&event->se_cv); 2573 mutex_exit(&event->se_mutex); 2574 2575 if (txid != 0) 2576 break; 2577 } 2578 2579 event = smb_llist_next(event_list, event); 2580 } 2581 2582 smb_llist_exit(event_list); 2583 } 2584 2585 /* 2586 * If txid is non-zero, notify the specified event. 2587 * Otherwise, notify all events. 2588 */ 2589 void 2590 smb_event_notify(smb_server_t *sv, uint32_t txid) 2591 { 2592 smb_event_t *event; 2593 smb_llist_t *event_list; 2594 2595 SMB_SERVER_VALID(sv); 2596 2597 event_list = &sv->sv_event_list; 2598 smb_llist_enter(event_list, RW_READER); 2599 2600 event = smb_llist_head(event_list); 2601 while (event) { 2602 SMB_EVENT_VALID(event); 2603 2604 if (txid == 0 || event->se_txid == txid) { 2605 mutex_enter(&event->se_mutex); 2606 event->se_notified = B_TRUE; 2607 cv_signal(&event->se_cv); 2608 mutex_exit(&event->se_mutex); 2609 2610 if (txid != 0) 2611 break; 2612 } 2613 2614 event = smb_llist_next(event_list, event); 2615 } 2616 2617 smb_llist_exit(event_list); 2618 } 2619 2620 /* 2621 * Allocate a new transaction id (txid). 2622 * 2623 * 0 or -1 are not assigned because they are used to detect invalid 2624 * conditions or to indicate all open id's. 2625 */ 2626 static uint32_t 2627 smb_event_alloc_txid(void) 2628 { 2629 static kmutex_t txmutex; 2630 static uint32_t txid; 2631 uint32_t txid_ret; 2632 2633 mutex_enter(&txmutex); 2634 2635 if (txid == 0) 2636 txid = ddi_get_lbolt() << 11; 2637 2638 do { 2639 ++txid; 2640 } while (txid == 0 || txid == (uint32_t)-1); 2641 2642 txid_ret = txid; 2643 mutex_exit(&txmutex); 2644 2645 return (txid_ret); 2646 } 2647 2648 /* 2649 * Called by the ioctl to find the corresponding 2650 * spooldoc node. removes node on success 2651 * 2652 * Return values 2653 * rc 2654 * B_FALSE - not found 2655 * B_TRUE - found 2656 * 2657 */ 2658 2659 static boolean_t 2660 smb_spool_lookup_doc_byfid(smb_server_t *sv, uint16_t fid, 2661 smb_kspooldoc_t *spdoc) 2662 { 2663 smb_kspooldoc_t *sp; 2664 smb_llist_t *splist; 2665 2666 splist = &sv->sp_info.sp_list; 2667 smb_llist_enter(splist, RW_WRITER); 2668 sp = smb_llist_head(splist); 2669 while (sp != NULL) { 2670 /* 2671 * check for a matching fid 2672 */ 2673 if (sp->sd_fid == fid) { 2674 *spdoc = *sp; 2675 smb_llist_remove(splist, sp); 2676 smb_llist_exit(splist); 2677 kmem_free(sp, sizeof (smb_kspooldoc_t)); 2678 return (B_TRUE); 2679 } 2680 sp = smb_llist_next(splist, sp); 2681 } 2682 cmn_err(CE_WARN, "smb_spool_lookup_user_byfid: no fid:%d", fid); 2683 smb_llist_exit(splist); 2684 return (B_FALSE); 2685 } 2686 2687 /* 2688 * Adds the spool fid to a linked list to be used 2689 * as a search key in the spooldoc queue 2690 * 2691 * Return values 2692 * rc non-zero error 2693 * rc zero success 2694 * 2695 */ 2696 2697 void 2698 smb_spool_add_fid(smb_server_t *sv, uint16_t fid) 2699 { 2700 smb_llist_t *fidlist; 2701 smb_spoolfid_t *sf; 2702 2703 if (sv->sv_cfg.skc_print_enable == 0) 2704 return; 2705 2706 sf = kmem_zalloc(sizeof (smb_spoolfid_t), KM_SLEEP); 2707 fidlist = &sv->sp_info.sp_fidlist; 2708 smb_llist_enter(fidlist, RW_WRITER); 2709 sf->sf_fid = fid; 2710 smb_llist_insert_tail(fidlist, sf); 2711 smb_llist_exit(fidlist); 2712 cv_broadcast(&sv->sp_info.sp_cv); 2713 } 2714 2715 /* 2716 * Called by the ioctl to get and remove the head of the fid list 2717 * 2718 * Return values 2719 * int fd 2720 * greater than 0 success 2721 * 0 - error 2722 * 2723 */ 2724 2725 static uint16_t 2726 smb_spool_get_fid(smb_server_t *sv) 2727 { 2728 smb_spoolfid_t *spfid; 2729 smb_llist_t *splist; 2730 uint16_t fid; 2731 2732 splist = &sv->sp_info.sp_fidlist; 2733 smb_llist_enter(splist, RW_WRITER); 2734 spfid = smb_llist_head(splist); 2735 if (spfid != NULL) { 2736 fid = spfid->sf_fid; 2737 smb_llist_remove(&sv->sp_info.sp_fidlist, spfid); 2738 kmem_free(spfid, sizeof (smb_spoolfid_t)); 2739 } else { 2740 fid = 0; 2741 } 2742 smb_llist_exit(splist); 2743 return (fid); 2744 } 2745 2746 /* 2747 * Adds the spooldoc to the tail of the spooldoc list 2748 * 2749 * Return values 2750 * rc non-zero error 2751 * rc zero success 2752 */ 2753 int 2754 smb_spool_add_doc(smb_tree_t *tree, smb_kspooldoc_t *sp) 2755 { 2756 smb_llist_t *splist; 2757 smb_server_t *sv = tree->t_server; 2758 int rc = 0; 2759 2760 splist = &sv->sp_info.sp_list; 2761 smb_llist_enter(splist, RW_WRITER); 2762 sp->sd_spool_num = atomic_inc_32_nv(&sv->sp_info.sp_cnt); 2763 smb_llist_insert_tail(splist, sp); 2764 smb_llist_exit(splist); 2765 2766 return (rc); 2767 } 2768 2769 /* 2770 * smb_server_create_session 2771 */ 2772 static void 2773 smb_server_create_session(smb_listener_daemon_t *ld, ksocket_t s_so) 2774 { 2775 smb_server_t *sv = ld->ld_sv; 2776 smb_session_t *session; 2777 smb_llist_t *sl; 2778 taskqid_t tqid; 2779 clock_t now; 2780 2781 session = smb_session_create(s_so, ld->ld_port, sv, 2782 ld->ld_family); 2783 2784 if (session == NULL) { 2785 /* This should be rare (create sleeps) */ 2786 smb_soshutdown(s_so); 2787 smb_sodestroy(s_so); 2788 cmn_err(CE_WARN, "SMB Session: alloc failed"); 2789 return; 2790 } 2791 2792 sl = &sv->sv_session_list; 2793 smb_llist_enter(sl, RW_WRITER); 2794 if (smb_llist_get_count(sl) >= sv->sv_cfg.skc_maxconnections) { 2795 /* 2796 * New session not in sv_session_list, so we can just 2797 * delete it directly. 2798 */ 2799 smb_llist_exit(sl); 2800 DTRACE_PROBE1(maxconn, smb_session_t *, session); 2801 smb_soshutdown(session->sock); 2802 smb_session_delete(session); 2803 goto logmaxconn; 2804 } 2805 smb_llist_insert_tail(sl, session); 2806 smb_llist_exit(sl); 2807 2808 /* 2809 * These taskq entries must run independently of one another, 2810 * so TQ_NOQUEUE. TQ_SLEEP (==0) just for clarity. 2811 */ 2812 tqid = taskq_dispatch(sv->sv_receiver_pool, 2813 smb_server_receiver, session, TQ_NOQUEUE | TQ_SLEEP); 2814 if (tqid != TASKQID_INVALID) { 2815 /* Success */ 2816 return; 2817 } 2818 2819 /* 2820 * Have: tqid == TASKQID_INVALID 2821 * We never entered smb_server_receiver() 2822 * so need to do its return cleanup 2823 */ 2824 DTRACE_PROBE1(maxconn, smb_session_t *, session); 2825 smb_session_disconnect(session); 2826 smb_session_logoff(session); 2827 smb_server_destroy_session(session); 2828 2829 logmaxconn: 2830 /* 2831 * If we hit max_connections, log something so an admin 2832 * can find out why new connections are failing, but 2833 * log this no more than once a minute. 2834 */ 2835 now = ddi_get_lbolt(); 2836 if (now > ld->ld_quiet) { 2837 ld->ld_quiet = now + SEC_TO_TICK(60); 2838 cmn_err(CE_WARN, "SMB can't create session: " 2839 "Would exceed max_connections."); 2840 } 2841 } 2842 2843 static void 2844 smb_server_destroy_session(smb_session_t *session) 2845 { 2846 smb_server_t *sv; 2847 smb_llist_t *ll; 2848 uint32_t count; 2849 2850 ASSERT(session->s_server != NULL); 2851 sv = session->s_server; 2852 ll = &sv->sv_session_list; 2853 2854 smb_llist_flush(&session->s_tree_list); 2855 smb_llist_flush(&session->s_user_list); 2856 2857 smb_llist_enter(ll, RW_WRITER); 2858 smb_llist_remove(ll, session); 2859 count = ll->ll_count; 2860 smb_llist_exit(ll); 2861 2862 /* 2863 * Normally, the session should have state SHUTDOWN here. 2864 * If the session has any ofiles remaining, eg. due to 2865 * forgotten ofile references or something, the state 2866 * will be _DISCONNECTED or _TERMINATED. Keep such 2867 * sessions in the list of zombies (for debugging). 2868 */ 2869 if (session->s_state == SMB_SESSION_STATE_SHUTDOWN) { 2870 smb_session_delete(session); 2871 } else { 2872 cmn_err(CE_NOTE, "!Leaked session: 0x%p", (void *)session); 2873 DTRACE_PROBE1(new__zombie, smb_session_t *, session); 2874 smb_llist_enter(&smb_server_session_zombies, RW_WRITER); 2875 smb_llist_insert_head(&smb_server_session_zombies, session); 2876 smb_llist_exit(&smb_server_session_zombies); 2877 } 2878 2879 if (count == 0) { 2880 /* See smb_server_shutdown */ 2881 cv_signal(&sv->sv_cv); 2882 } 2883 } 2884