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) 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <fcntl.h> 30 #include <attr.h> 31 #include <unistd.h> 32 #include <libuutil.h> 33 #include <libzfs.h> 34 #include <assert.h> 35 #include <stddef.h> 36 #include <strings.h> 37 #include <errno.h> 38 #include <synch.h> 39 #include <smbsrv/smb_xdr.h> 40 #include <smbsrv/libmlsvc.h> 41 #include <smbsrv/smb_idmap.h> 42 #include <mlsvc.h> 43 #include <sys/avl.h> 44 45 /* 46 * smb_quota subsystem interface - mlsvc.h 47 * --------------------------------------- 48 * Management of the smb_quota_fs_list (see below). 49 * smb_quota_init 50 * smb_quota_fini 51 * smb_quota_add_fs 52 * smb_quota_remove_fs 53 * 54 * smb_quota public interface - libmlsvc.h 55 * --------------------------------------- 56 * Handling of requests to query and set quota data on a filesystem. 57 * smb_quota_query - query user/group quotas on a filesystem 58 * smb_quota_set - set user/group quotas ona filesystem 59 * smb_quota_free - delete the quota list created in smb_quota_query 60 */ 61 62 /* 63 * Querying user & group quotas - smb_quota_query 64 * 65 * In order to fulfill the quota query requests that can be received 66 * from clients, it is required that the quota data can be provided in 67 * a well defined and consistent order, and that a request can specify 68 * at which quota entry to begin the query. 69 * 70 * Quota Tree 71 * Since the file system does not support the above, an avl tree is 72 * populated with the file system's user and group quota data, and 73 * then used to provide the data to respond to query requests. The 74 * avl tree is indexed by the SID. 75 * Each node of the avl tree is an smb_quota_t structure. 76 * 77 * Quota List 78 * There is a list of avl trees, one per file system. 79 * Each node in the list is an smb_quota_tree_t structure. 80 * The list is created via a call to smb_quota_init() when the library 81 * is initialized, and destroyed via a call to smb_quota_fini() when 82 * the library is fini'd. 83 * 84 * An avl tree for a specific file system is created and added to the 85 * list via a call to smb_quota_add_fs() when the file system is shared, 86 * and removed from the list via a call to smb_quota_remove_fs() when 87 * the file system is unshared. 88 * 89 * An avl tree is (re)populated, if required, whenever a quota request 90 * (EXCLUDING a resume request) is received for its filesystem. The 91 * avl tree is considered to be expired (needs to be repopulated) if 92 * either of the following have occurred since it was last (re)populated: 93 * - SMB_QUOTA_REFRESH seconds have elapsed OR 94 * - a quota set operation has been performed on its file system 95 * 96 * In order to perform a smb_quota_query/set operation on a file system 97 * the appropriate quota tree must be identified and locked via a call 98 * to smb_quota_tree_lookup(), The quota tree is locked (qt_locked == B_TRUE) 99 * until the caller releases it via a call to smb_quota_tree_release(). 100 */ 101 102 /* 103 * smb_quota_tree_t 104 * Represents an avl tree of user quotas for a file system. 105 * 106 * qt_refcnt - a count of the number of users of the tree. 107 * qt_refcnt is also incremented and decremented when the tree is 108 * added to and removed from the quota list. 109 * The tree cannot be deleted until this count is zero. 110 * 111 * qt_sharecnt - a count of the shares of the file system which the 112 * tree represents. smb_quota_remove_fs() cannot remove the tree from 113 * removed from the quota list until this count is zero. 114 * 115 * qt_locked - B_TRUE if someone is currently using the tree, in 116 * which case a lookup will wait for the tree to become available. 117 */ 118 typedef struct smb_quota_tree { 119 list_node_t qt_node; 120 char *qt_path; 121 time_t qt_timestamp; 122 uint32_t qt_refcnt; 123 uint32_t qt_sharecnt; 124 boolean_t qt_locked; 125 avl_tree_t qt_avl; 126 mutex_t qt_mutex; 127 }smb_quota_tree_t; 128 129 /* 130 * smb_quota_fs_list 131 * list of quota trees; one per shared file system. 132 */ 133 static list_t smb_quota_fs_list; 134 static boolean_t smb_quota_list_init = B_FALSE; 135 static boolean_t smb_quota_shutdown = B_FALSE; 136 static mutex_t smb_quota_list_mutex = DEFAULTMUTEX; 137 static cond_t smb_quota_list_condvar; 138 static uint32_t smb_quota_tree_cnt = 0; 139 static int smb_quota_fini_timeout = 1; /* seconds */ 140 141 /* 142 * smb_quota_zfs_handle_t 143 * handle to zfs library and dataset 144 */ 145 typedef struct smb_quota_zfs_handle { 146 libzfs_handle_t *z_lib; 147 zfs_handle_t *z_fs; 148 } smb_quota_zfs_handle_t; 149 150 /* 151 * smb_quota_zfs_arg_t 152 * arg passed to zfs callback when querying quota properties 153 */ 154 typedef struct smb_quota_zfs_arg { 155 zfs_userquota_prop_t qa_prop; 156 avl_tree_t *qa_avl; 157 } smb_quota_zfs_arg_t; 158 159 static void smb_quota_add_ctrldir(const char *); 160 static void smb_quota_remove_ctrldir(const char *); 161 162 static smb_quota_tree_t *smb_quota_tree_create(const char *); 163 static void smb_quota_tree_delete(smb_quota_tree_t *); 164 165 static smb_quota_tree_t *smb_quota_tree_lookup(const char *); 166 static void smb_quota_tree_release(smb_quota_tree_t *); 167 static boolean_t smb_quota_tree_match(smb_quota_tree_t *, const char *); 168 static int smb_quota_sid_cmp(const void *, const void *); 169 static uint32_t smb_quota_tree_populate(smb_quota_tree_t *); 170 static boolean_t smb_quota_tree_expired(smb_quota_tree_t *); 171 static void smb_quota_tree_set_expired(smb_quota_tree_t *); 172 173 static uint32_t smb_quota_zfs_init(const char *, smb_quota_zfs_handle_t *); 174 static void smb_quota_zfs_fini(smb_quota_zfs_handle_t *); 175 static uint32_t smb_quota_zfs_get_quotas(smb_quota_tree_t *); 176 static int smb_quota_zfs_callback(void *, const char *, uid_t, uint64_t); 177 static uint32_t smb_quota_zfs_set_quotas(smb_quota_tree_t *, smb_quota_set_t *); 178 static int smb_quota_sidstr(uint32_t, zfs_userquota_prop_t, char *); 179 static uint32_t smb_quota_sidtype(smb_quota_tree_t *, char *); 180 static int smb_quota_getid(char *, uint32_t, uint32_t *); 181 182 static uint32_t smb_quota_query_all(smb_quota_tree_t *, 183 smb_quota_query_t *, smb_quota_response_t *); 184 static uint32_t smb_quota_query_list(smb_quota_tree_t *, 185 smb_quota_query_t *, smb_quota_response_t *); 186 187 #define SMB_QUOTA_REFRESH 2 188 #define SMB_QUOTA_CMD_LENGTH 21 189 #define SMB_QUOTA_CMD_STR_LENGTH SMB_SID_STRSZ+SMB_QUOTA_CMD_LENGTH 190 191 /* 192 * In order to display the quota properties tab, windows clients 193 * check for the existence of the quota control file. 194 */ 195 #define SMB_QUOTA_CNTRL_DIR ".$EXTEND" 196 #define SMB_QUOTA_CNTRL_FILE "$QUOTA" 197 #define SMB_QUOTA_CNTRL_INDEX_XATTR "SUNWsmb:$Q:$INDEX_ALLOCATION" 198 /* 199 * Note: this line needs to have the same format as what acl_totext() returns. 200 */ 201 #define SMB_QUOTA_CNTRL_PERM "everyone@:rw-p--aARWc--s:-------:allow" 202 203 /* 204 * smb_quota_init 205 * Initialize the list to hold the quota trees. 206 */ 207 void 208 smb_quota_init(void) 209 { 210 (void) mutex_lock(&smb_quota_list_mutex); 211 if (!smb_quota_list_init) { 212 list_create(&smb_quota_fs_list, sizeof (smb_quota_tree_t), 213 offsetof(smb_quota_tree_t, qt_node)); 214 smb_quota_list_init = B_TRUE; 215 smb_quota_shutdown = B_FALSE; 216 } 217 (void) mutex_unlock(&smb_quota_list_mutex); 218 } 219 220 /* 221 * smb_quota_fini 222 * 223 * Wait for each quota tree to not be in use (qt_refcnt == 1) 224 * then remove it from the list and delete it. 225 */ 226 void 227 smb_quota_fini(void) 228 { 229 smb_quota_tree_t *qtree, *qtree_next; 230 boolean_t remove; 231 struct timespec tswait; 232 tswait.tv_sec = smb_quota_fini_timeout; 233 tswait.tv_nsec = 0; 234 235 (void) mutex_lock(&smb_quota_list_mutex); 236 smb_quota_shutdown = B_TRUE; 237 238 if (!smb_quota_list_init) { 239 (void) mutex_unlock(&smb_quota_list_mutex); 240 return; 241 } 242 243 (void) cond_broadcast(&smb_quota_list_condvar); 244 245 while (!list_is_empty(&smb_quota_fs_list)) { 246 qtree = list_head(&smb_quota_fs_list); 247 while (qtree != NULL) { 248 qtree_next = list_next(&smb_quota_fs_list, qtree); 249 250 (void) mutex_lock(&qtree->qt_mutex); 251 remove = (qtree->qt_refcnt == 1); 252 if (remove) { 253 list_remove(&smb_quota_fs_list, qtree); 254 --qtree->qt_refcnt; 255 } 256 (void) mutex_unlock(&qtree->qt_mutex); 257 258 if (remove) 259 smb_quota_tree_delete(qtree); 260 261 qtree = qtree_next; 262 } 263 264 if (!list_is_empty(&smb_quota_fs_list)) { 265 if (cond_reltimedwait(&smb_quota_list_condvar, 266 &smb_quota_list_mutex, &tswait) == ETIME) { 267 syslog(LOG_WARNING, 268 "quota shutdown timeout expired"); 269 break; 270 } 271 } 272 } 273 274 if (list_is_empty(&smb_quota_fs_list)) { 275 list_destroy(&smb_quota_fs_list); 276 smb_quota_list_init = B_FALSE; 277 } 278 279 (void) mutex_unlock(&smb_quota_list_mutex); 280 } 281 282 /* 283 * smb_quota_add_fs 284 * 285 * If there is not a quota tree representing the specified path, 286 * create one and add it to the list. 287 */ 288 void 289 smb_quota_add_fs(const char *path) 290 { 291 smb_quota_tree_t *qtree; 292 293 (void) mutex_lock(&smb_quota_list_mutex); 294 295 if (!smb_quota_list_init || smb_quota_shutdown) { 296 (void) mutex_unlock(&smb_quota_list_mutex); 297 return; 298 } 299 300 qtree = list_head(&smb_quota_fs_list); 301 while (qtree != NULL) { 302 if (smb_quota_tree_match(qtree, path)) { 303 (void) mutex_lock(&qtree->qt_mutex); 304 ++qtree->qt_sharecnt; 305 (void) mutex_unlock(&qtree->qt_mutex); 306 break; 307 } 308 qtree = list_next(&smb_quota_fs_list, qtree); 309 } 310 311 if (qtree == NULL) { 312 qtree = smb_quota_tree_create(path); 313 if (qtree) 314 list_insert_head(&smb_quota_fs_list, (void *)qtree); 315 } 316 317 if (qtree) 318 smb_quota_add_ctrldir(path); 319 320 (void) mutex_unlock(&smb_quota_list_mutex); 321 } 322 323 /* 324 * smb_quota_remove_fs 325 * 326 * If this is the last share that the quota tree represents 327 * (qtree->qt_sharecnt == 0) remove the qtree from the list. 328 * The qtree will be deleted if/when there is nobody using it 329 * (qtree->qt_refcnt == 0). 330 */ 331 void 332 smb_quota_remove_fs(const char *path) 333 { 334 smb_quota_tree_t *qtree; 335 boolean_t delete = B_FALSE; 336 337 (void) mutex_lock(&smb_quota_list_mutex); 338 339 if (!smb_quota_list_init || smb_quota_shutdown) { 340 (void) mutex_unlock(&smb_quota_list_mutex); 341 return; 342 } 343 344 qtree = list_head(&smb_quota_fs_list); 345 while (qtree != NULL) { 346 assert(qtree->qt_refcnt > 0); 347 if (smb_quota_tree_match(qtree, path)) { 348 (void) mutex_lock(&qtree->qt_mutex); 349 --qtree->qt_sharecnt; 350 if (qtree->qt_sharecnt == 0) { 351 list_remove(&smb_quota_fs_list, (void *)qtree); 352 smb_quota_remove_ctrldir(qtree->qt_path); 353 --(qtree->qt_refcnt); 354 delete = (qtree->qt_refcnt == 0); 355 } 356 (void) mutex_unlock(&qtree->qt_mutex); 357 if (delete) 358 smb_quota_tree_delete(qtree); 359 break; 360 } 361 qtree = list_next(&smb_quota_fs_list, qtree); 362 } 363 (void) mutex_unlock(&smb_quota_list_mutex); 364 } 365 366 /* 367 * smb_quota_query 368 * 369 * Get list of user/group quotas entries. 370 * Request->qq_query_op determines whether to get quota entries 371 * for the specified SIDs (smb_quota_query_list) OR to get all 372 * quota entries, optionally starting at a specified SID. 373 * 374 * Returns NT_STATUS codes. 375 */ 376 uint32_t 377 smb_quota_query(smb_quota_query_t *request, smb_quota_response_t *reply) 378 { 379 uint32_t status; 380 smb_quota_tree_t *qtree; 381 smb_quota_query_op_t query_op = request->qq_query_op; 382 383 list_create(&reply->qr_quota_list, sizeof (smb_quota_t), 384 offsetof(smb_quota_t, q_list_node)); 385 386 qtree = smb_quota_tree_lookup(request->qq_root_path); 387 if (qtree == NULL) 388 return (NT_STATUS_INVALID_PARAMETER); 389 390 /* If NOT resuming a previous query all, refresh qtree if required */ 391 if ((query_op != SMB_QUOTA_QUERY_ALL) || (request->qq_restart)) { 392 status = smb_quota_tree_populate(qtree); 393 if (status != NT_STATUS_SUCCESS) { 394 smb_quota_tree_release(qtree); 395 return (status); 396 } 397 } 398 399 switch (query_op) { 400 case SMB_QUOTA_QUERY_SIDLIST: 401 status = smb_quota_query_list(qtree, request, reply); 402 break; 403 case SMB_QUOTA_QUERY_STARTSID: 404 case SMB_QUOTA_QUERY_ALL: 405 status = smb_quota_query_all(qtree, request, reply); 406 break; 407 case SMB_QUOTA_QUERY_INVALID_OP: 408 default: 409 status = NT_STATUS_INVALID_PARAMETER; 410 break; 411 } 412 413 smb_quota_tree_release(qtree); 414 415 return (status); 416 } 417 418 /* 419 * smb_quota_set 420 * 421 * Set the list of quota entries. 422 */ 423 uint32_t 424 smb_quota_set(smb_quota_set_t *request) 425 { 426 uint32_t status; 427 smb_quota_tree_t *qtree; 428 429 qtree = smb_quota_tree_lookup(request->qs_root_path); 430 if (qtree == NULL) 431 return (NT_STATUS_INVALID_PARAMETER); 432 433 status = smb_quota_zfs_set_quotas(qtree, request); 434 435 smb_quota_tree_set_expired(qtree); 436 smb_quota_tree_release(qtree); 437 438 return (status); 439 } 440 441 /* 442 * smb_quota_free 443 * 444 * This method frees quota entries. 445 */ 446 void 447 smb_quota_free(smb_quota_response_t *reply) 448 { 449 list_t *list = &reply->qr_quota_list; 450 smb_quota_t *quota; 451 452 while ((quota = list_head(list)) != NULL) { 453 list_remove(list, quota); 454 free(quota); 455 } 456 457 list_destroy(list); 458 } 459 460 /* 461 * smb_quota_query_all 462 * 463 * Query quotas sequentially from tree, optionally starting at a 464 * specified sid. If request->qq_single is TRUE only one quota 465 * should be returned, otherwise up to request->qq_max_quota 466 * should be returned. 467 * 468 * SMB_QUOTA_QUERY_STARTSID 469 * The query should start at the startsid, the first sid in 470 * request->qq_sid_list. 471 * 472 * SMQ_QUOTA_QUERY_ALL 473 * If request->qq_restart the query should restart at the start 474 * of the avl tree. Otherwise the first sid in request->qq_sid_list 475 * is the resume sid and the query should start at the tree entry 476 * after the one it refers to. 477 * 478 * Returns NT_STATUS codes. 479 */ 480 static uint32_t 481 smb_quota_query_all(smb_quota_tree_t *qtree, smb_quota_query_t *request, 482 smb_quota_response_t *reply) 483 { 484 avl_tree_t *avl_tree = &qtree->qt_avl; 485 avl_index_t where; 486 list_t *sid_list, *quota_list; 487 smb_quota_sid_t *sid; 488 smb_quota_t *quota, *quotal, key; 489 uint32_t count; 490 491 /* find starting sid */ 492 if (request->qq_query_op == SMB_QUOTA_QUERY_STARTSID) { 493 sid_list = &request->qq_sid_list; 494 sid = list_head(sid_list); 495 (void) strlcpy(key.q_sidstr, sid->qs_sidstr, SMB_SID_STRSZ); 496 quota = avl_find(avl_tree, &key, &where); 497 if (quota == NULL) 498 return (NT_STATUS_INVALID_PARAMETER); 499 } else if (request->qq_restart) { 500 quota = avl_first(avl_tree); 501 if (quota == NULL) 502 return (NT_STATUS_NO_MORE_ENTRIES); 503 } else { 504 sid_list = &request->qq_sid_list; 505 sid = list_head(sid_list); 506 (void) strlcpy(key.q_sidstr, sid->qs_sidstr, SMB_SID_STRSZ); 507 quota = avl_find(avl_tree, &key, &where); 508 if (quota == NULL) 509 return (NT_STATUS_INVALID_PARAMETER); 510 quota = AVL_NEXT(avl_tree, quota); 511 if (quota == NULL) 512 return (NT_STATUS_NO_MORE_ENTRIES); 513 } 514 515 if ((request->qq_single) && (request->qq_max_quota > 1)) 516 request->qq_max_quota = 1; 517 518 quota_list = &reply->qr_quota_list; 519 count = 0; 520 while (quota) { 521 if (count >= request->qq_max_quota) 522 break; 523 524 quotal = malloc(sizeof (smb_quota_t)); 525 if (quotal == NULL) 526 return (NT_STATUS_NO_MEMORY); 527 bcopy(quota, quotal, sizeof (smb_quota_t)); 528 529 list_insert_tail(quota_list, quotal); 530 ++count; 531 532 quota = AVL_NEXT(avl_tree, quota); 533 } 534 535 return (NT_STATUS_SUCCESS); 536 } 537 538 /* 539 * smb_quota_query_list 540 * 541 * Iterate through request sid list querying the avl tree for each. 542 * Insert an entry in the reply quota list for each sid. 543 * For any sid that cannot be found in the avl tree, the reply 544 * quota list entry should contain zeros. 545 */ 546 static uint32_t 547 smb_quota_query_list(smb_quota_tree_t *qtree, smb_quota_query_t *request, 548 smb_quota_response_t *reply) 549 { 550 avl_tree_t *avl_tree = &qtree->qt_avl; 551 avl_index_t where; 552 list_t *sid_list, *quota_list; 553 smb_quota_sid_t *sid; 554 smb_quota_t *quota, *quotal, key; 555 556 quota_list = &reply->qr_quota_list; 557 sid_list = &request->qq_sid_list; 558 sid = list_head(sid_list); 559 while (sid) { 560 quotal = malloc(sizeof (smb_quota_t)); 561 if (quotal == NULL) 562 return (NT_STATUS_NO_MEMORY); 563 564 (void) strlcpy(key.q_sidstr, sid->qs_sidstr, SMB_SID_STRSZ); 565 quota = avl_find(avl_tree, &key, &where); 566 if (quota) { 567 bcopy(quota, quotal, sizeof (smb_quota_t)); 568 } else { 569 bzero(quotal, sizeof (smb_quota_t)); 570 (void) strlcpy(quotal->q_sidstr, sid->qs_sidstr, 571 SMB_SID_STRSZ); 572 } 573 574 list_insert_tail(quota_list, quotal); 575 sid = list_next(sid_list, sid); 576 } 577 578 return (NT_STATUS_SUCCESS); 579 } 580 581 /* 582 * smb_quota_zfs_set_quotas 583 * 584 * This method sets the list of quota entries. 585 * 586 * A quota list or threshold value of SMB_QUOTA_UNLIMITED means that 587 * the user / group does not have a quota limit. In ZFS this maps to 588 * 0 (none). 589 * A quota list or threshold value of (SMB_QUOTA_UNLIMITED - 1) means 590 * that the user / group quota should be removed. In ZFS this maps to 591 * 0 (none). 592 */ 593 static uint32_t 594 smb_quota_zfs_set_quotas(smb_quota_tree_t *qtree, smb_quota_set_t *request) 595 { 596 smb_quota_zfs_handle_t zfs_hdl; 597 char *typestr, qsetstr[SMB_QUOTA_CMD_STR_LENGTH]; 598 char qlimit[SMB_QUOTA_CMD_LENGTH]; 599 list_t *quota_list; 600 smb_quota_t *quota; 601 uint32_t id; 602 uint32_t status = NT_STATUS_SUCCESS; 603 uint32_t sidtype; 604 605 status = smb_quota_zfs_init(request->qs_root_path, &zfs_hdl); 606 if (status != NT_STATUS_SUCCESS) 607 return (status); 608 609 quota_list = &request->qs_quota_list; 610 quota = list_head(quota_list); 611 612 while (quota) { 613 if ((quota->q_limit == SMB_QUOTA_UNLIMITED) || 614 (quota->q_limit == (SMB_QUOTA_UNLIMITED - 1))) { 615 quota->q_limit = 0; 616 } 617 (void) snprintf(qlimit, SMB_QUOTA_CMD_LENGTH, "%llu", 618 quota->q_limit); 619 620 sidtype = smb_quota_sidtype(qtree, quota->q_sidstr); 621 switch (sidtype) { 622 case SidTypeUser: 623 typestr = "userquota"; 624 break; 625 case SidTypeWellKnownGroup: 626 case SidTypeGroup: 627 case SidTypeAlias: 628 typestr = "groupquota"; 629 break; 630 default: 631 syslog(LOG_WARNING, "Failed to set quota for %s: " 632 "%s (%d) not valid for quotas", quota->q_sidstr, 633 smb_sid_type2str(sidtype), sidtype); 634 quota = list_next(quota_list, quota); 635 continue; 636 } 637 638 if ((smb_quota_getid(quota->q_sidstr, sidtype, &id) == 0) && 639 !(IDMAP_ID_IS_EPHEMERAL(id))) { 640 (void) snprintf(qsetstr, SMB_QUOTA_CMD_STR_LENGTH, 641 "%s@%d", typestr, id); 642 } else { 643 (void) snprintf(qsetstr, SMB_QUOTA_CMD_STR_LENGTH, 644 "%s@%s", typestr, quota->q_sidstr); 645 } 646 647 errno = 0; 648 if (zfs_prop_set(zfs_hdl.z_fs, qsetstr, qlimit) != 0) { 649 syslog(LOG_WARNING, "Failed to set quota for %s: %s", 650 quota->q_sidstr, strerror(errno)); 651 status = NT_STATUS_INVALID_PARAMETER; 652 break; 653 } 654 655 quota = list_next(quota_list, quota); 656 } 657 658 smb_quota_zfs_fini(&zfs_hdl); 659 return (status); 660 } 661 662 /* 663 * smb_quota_sidtype 664 * 665 * Determine the type of the sid. If the sid exists in 666 * the qtree get its type from there, otherwise do an 667 * lsa_lookup_sid(). 668 */ 669 static uint32_t 670 smb_quota_sidtype(smb_quota_tree_t *qtree, char *sidstr) 671 { 672 smb_quota_t key, *quota; 673 avl_index_t where; 674 smb_sid_t *sid = NULL; 675 smb_account_t ainfo; 676 uint32_t sidtype = SidTypeUnknown; 677 678 (void) strlcpy(key.q_sidstr, sidstr, SMB_SID_STRSZ); 679 quota = avl_find(&qtree->qt_avl, &key, &where); 680 if (quota) 681 return (quota->q_sidtype); 682 683 sid = smb_sid_fromstr(sidstr); 684 if (sid != NULL) { 685 if (lsa_lookup_sid(sid, &ainfo) == NT_STATUS_SUCCESS) { 686 sidtype = ainfo.a_type; 687 smb_account_free(&ainfo); 688 } 689 smb_sid_free(sid); 690 } 691 return (sidtype); 692 } 693 694 /* 695 * smb_quota_getid 696 * 697 * Get the user/group id for the sid. 698 */ 699 static int 700 smb_quota_getid(char *sidstr, uint32_t sidtype, uint32_t *id) 701 { 702 int rc = 0; 703 smb_sid_t *sid = NULL; 704 int idtype; 705 706 sid = smb_sid_fromstr(sidstr); 707 if (sid == NULL) 708 return (-1); 709 710 switch (sidtype) { 711 case SidTypeUser: 712 idtype = SMB_IDMAP_USER; 713 break; 714 case SidTypeWellKnownGroup: 715 case SidTypeGroup: 716 case SidTypeAlias: 717 idtype = SMB_IDMAP_GROUP; 718 break; 719 default: 720 rc = -1; 721 break; 722 } 723 724 if (rc == 0) 725 rc = smb_idmap_getid(sid, id, &idtype); 726 727 smb_sid_free(sid); 728 729 return (rc); 730 } 731 732 /* 733 * smb_quota_tree_lookup 734 * 735 * Find the quota tree in smb_quota_fs_list. 736 * 737 * If the tree is found but is locked, waits for it to become available. 738 * If the tree is available, locks it and returns it. 739 * Otherwise, returns NULL. 740 */ 741 static smb_quota_tree_t * 742 smb_quota_tree_lookup(const char *path) 743 { 744 smb_quota_tree_t *qtree = NULL; 745 746 assert(path); 747 (void) mutex_lock(&smb_quota_list_mutex); 748 749 qtree = list_head(&smb_quota_fs_list); 750 while (qtree != NULL) { 751 if (!smb_quota_list_init || smb_quota_shutdown) { 752 (void) mutex_unlock(&smb_quota_list_mutex); 753 return (NULL); 754 } 755 756 (void) mutex_lock(&qtree->qt_mutex); 757 assert(qtree->qt_refcnt > 0); 758 759 if (!smb_quota_tree_match(qtree, path)) { 760 (void) mutex_unlock(&qtree->qt_mutex); 761 qtree = list_next(&smb_quota_fs_list, qtree); 762 continue; 763 } 764 765 if (qtree->qt_locked) { 766 (void) mutex_unlock(&qtree->qt_mutex); 767 (void) cond_wait(&smb_quota_list_condvar, 768 &smb_quota_list_mutex); 769 qtree = list_head(&smb_quota_fs_list); 770 continue; 771 } 772 773 ++(qtree->qt_refcnt); 774 qtree->qt_locked = B_TRUE; 775 (void) mutex_unlock(&qtree->qt_mutex); 776 break; 777 }; 778 779 (void) mutex_unlock(&smb_quota_list_mutex); 780 return (qtree); 781 } 782 783 /* 784 * smb_quota_tree_release 785 */ 786 static void 787 smb_quota_tree_release(smb_quota_tree_t *qtree) 788 { 789 boolean_t delete; 790 791 (void) mutex_lock(&qtree->qt_mutex); 792 assert(qtree->qt_locked); 793 assert(qtree->qt_refcnt > 0); 794 795 --(qtree->qt_refcnt); 796 qtree->qt_locked = B_FALSE; 797 delete = (qtree->qt_refcnt == 0); 798 (void) mutex_unlock(&qtree->qt_mutex); 799 800 (void) mutex_lock(&smb_quota_list_mutex); 801 if (delete) 802 smb_quota_tree_delete(qtree); 803 (void) cond_broadcast(&smb_quota_list_condvar); 804 (void) mutex_unlock(&smb_quota_list_mutex); 805 } 806 807 /* 808 * smb_quota_tree_match 809 * 810 * Determine if qtree represents the file system identified by path 811 */ 812 static boolean_t 813 smb_quota_tree_match(smb_quota_tree_t *qtree, const char *path) 814 { 815 return (strncmp(qtree->qt_path, path, MAXPATHLEN) == 0); 816 } 817 818 /* 819 * smb_quota_tree_create 820 * 821 * Create and initialize an smb_quota_tree_t structure 822 */ 823 static smb_quota_tree_t * 824 smb_quota_tree_create(const char *path) 825 { 826 smb_quota_tree_t *qtree; 827 828 assert(MUTEX_HELD(&smb_quota_list_mutex)); 829 830 qtree = calloc(sizeof (smb_quota_tree_t), 1); 831 if (qtree == NULL) 832 return (NULL); 833 834 qtree->qt_path = strdup(path); 835 if (qtree->qt_path == NULL) { 836 free(qtree); 837 return (NULL); 838 } 839 840 qtree->qt_timestamp = 0; 841 qtree->qt_locked = B_FALSE; 842 qtree->qt_refcnt = 1; 843 qtree->qt_sharecnt = 1; 844 845 avl_create(&qtree->qt_avl, smb_quota_sid_cmp, 846 sizeof (smb_quota_t), offsetof(smb_quota_t, q_avl_node)); 847 848 ++smb_quota_tree_cnt; 849 return (qtree); 850 } 851 852 /* 853 * smb_quota_tree_delete 854 * 855 * Free and delete the smb_quota_tree_t structure. 856 * qtree must have no users (refcnt == 0). 857 */ 858 static void 859 smb_quota_tree_delete(smb_quota_tree_t *qtree) 860 { 861 void *cookie = NULL; 862 smb_quota_t *node; 863 864 assert(MUTEX_HELD(&smb_quota_list_mutex)); 865 assert(qtree->qt_refcnt == 0); 866 867 while ((node = avl_destroy_nodes(&qtree->qt_avl, &cookie)) != NULL) 868 free(node); 869 avl_destroy(&qtree->qt_avl); 870 871 free(qtree->qt_path); 872 free(qtree); 873 874 --smb_quota_tree_cnt; 875 } 876 877 /* 878 * smb_quota_sid_cmp 879 * 880 * Comparision function for nodes in an AVL tree which holds quota 881 * entries indexed by SID. 882 */ 883 static int 884 smb_quota_sid_cmp(const void *l_arg, const void *r_arg) 885 { 886 const char *l_sid = ((smb_quota_t *)l_arg)->q_sidstr; 887 const char *r_sid = ((smb_quota_t *)r_arg)->q_sidstr; 888 int ret; 889 890 ret = strncasecmp(l_sid, r_sid, SMB_SID_STRSZ); 891 892 if (ret > 0) 893 return (1); 894 if (ret < 0) 895 return (-1); 896 return (0); 897 } 898 899 /* 900 * smb_quota_tree_populate 901 * 902 * If the quota tree needs to be (re)populated: 903 * - delete the qtree's contents 904 * - repopulate the qtree from zfs 905 * - set the qtree's timestamp. 906 */ 907 static uint32_t 908 smb_quota_tree_populate(smb_quota_tree_t *qtree) 909 { 910 void *cookie = NULL; 911 void *node; 912 uint32_t status; 913 914 assert(qtree->qt_locked); 915 916 if (!smb_quota_tree_expired(qtree)) 917 return (NT_STATUS_SUCCESS); 918 919 while ((node = avl_destroy_nodes(&qtree->qt_avl, &cookie)) != NULL) 920 free(node); 921 922 status = smb_quota_zfs_get_quotas(qtree); 923 if (status != NT_STATUS_SUCCESS) 924 return (status); 925 926 qtree->qt_timestamp = time(NULL); 927 928 return (NT_STATUS_SUCCESS); 929 } 930 931 static boolean_t 932 smb_quota_tree_expired(smb_quota_tree_t *qtree) 933 { 934 time_t tnow = time(NULL); 935 return ((tnow - qtree->qt_timestamp) > SMB_QUOTA_REFRESH); 936 } 937 938 static void 939 smb_quota_tree_set_expired(smb_quota_tree_t *qtree) 940 { 941 qtree->qt_timestamp = 0; 942 } 943 944 /* 945 * smb_quota_zfs_get_quotas 946 * 947 * Get user and group quotas from ZFS and use them to 948 * populate the quota tree. 949 */ 950 static uint32_t 951 smb_quota_zfs_get_quotas(smb_quota_tree_t *qtree) 952 { 953 smb_quota_zfs_handle_t zfs_hdl; 954 smb_quota_zfs_arg_t arg; 955 zfs_userquota_prop_t p; 956 uint32_t status = NT_STATUS_SUCCESS; 957 958 status = smb_quota_zfs_init(qtree->qt_path, &zfs_hdl); 959 if (status != NT_STATUS_SUCCESS) 960 return (status); 961 962 arg.qa_avl = &qtree->qt_avl; 963 for (p = 0; p < ZFS_NUM_USERQUOTA_PROPS; p++) { 964 arg.qa_prop = p; 965 if (zfs_userspace(zfs_hdl.z_fs, p, 966 smb_quota_zfs_callback, &arg) != 0) { 967 status = NT_STATUS_INTERNAL_ERROR; 968 break; 969 } 970 } 971 972 smb_quota_zfs_fini(&zfs_hdl); 973 return (status); 974 } 975 976 /* 977 * smb_quota_zfs_callback 978 * 979 * Find or create a node in the avl tree (arg->qa_avl) that matches 980 * the SID derived from domain and rid. If no domain is specified, 981 * lookup the sid (smb_quota_sidstr()). 982 * Populate the node. 983 * The property type (arg->qa_prop) determines which property 'space' 984 * refers to. 985 */ 986 static int 987 smb_quota_zfs_callback(void *arg, const char *domain, uid_t rid, uint64_t space) 988 { 989 smb_quota_zfs_arg_t *qarg = (smb_quota_zfs_arg_t *)arg; 990 zfs_userquota_prop_t qprop = qarg->qa_prop; 991 avl_tree_t *avl_tree = qarg->qa_avl; 992 avl_index_t where; 993 smb_quota_t *quota, key; 994 995 if (domain == NULL || domain[0] == '\0') { 996 if (smb_quota_sidstr(rid, qprop, key.q_sidstr) != 0) 997 return (0); 998 } else { 999 (void) snprintf(key.q_sidstr, SMB_SID_STRSZ, "%s-%u", 1000 domain, (uint32_t)rid); 1001 } 1002 1003 quota = avl_find(avl_tree, &key, &where); 1004 if (quota == NULL) { 1005 quota = malloc(sizeof (smb_quota_t)); 1006 if (quota == NULL) 1007 return (NT_STATUS_NO_MEMORY); 1008 bzero(quota, sizeof (smb_quota_t)); 1009 quota->q_thresh = SMB_QUOTA_UNLIMITED; 1010 quota->q_limit = SMB_QUOTA_UNLIMITED; 1011 avl_insert(avl_tree, (void *)quota, where); 1012 (void) strlcpy(quota->q_sidstr, key.q_sidstr, SMB_SID_STRSZ); 1013 } 1014 1015 switch (qprop) { 1016 case ZFS_PROP_USERUSED: 1017 quota->q_sidtype = SidTypeUser; 1018 quota->q_used = space; 1019 break; 1020 case ZFS_PROP_GROUPUSED: 1021 quota->q_sidtype = SidTypeGroup; 1022 quota->q_used = space; 1023 break; 1024 case ZFS_PROP_USERQUOTA: 1025 quota->q_sidtype = SidTypeUser; 1026 quota->q_limit = space; 1027 break; 1028 case ZFS_PROP_GROUPQUOTA: 1029 quota->q_sidtype = SidTypeGroup; 1030 quota->q_limit = space; 1031 break; 1032 default: 1033 break; 1034 } 1035 1036 quota->q_thresh = quota->q_limit; 1037 1038 return (0); 1039 } 1040 1041 /* 1042 * smb_quota_sidstr 1043 * 1044 * Use idmap to get the sid for the specified id and return 1045 * the string version of the sid in sidstr. 1046 * sidstr must be a buffer of at least SMB_SID_STRSZ. 1047 */ 1048 static int 1049 smb_quota_sidstr(uint32_t id, zfs_userquota_prop_t qprop, char *sidstr) 1050 { 1051 int idtype; 1052 smb_sid_t *sid; 1053 1054 switch (qprop) { 1055 case ZFS_PROP_USERUSED: 1056 case ZFS_PROP_USERQUOTA: 1057 idtype = SMB_IDMAP_USER; 1058 break; 1059 case ZFS_PROP_GROUPUSED: 1060 case ZFS_PROP_GROUPQUOTA: 1061 idtype = SMB_IDMAP_GROUP; 1062 break; 1063 default: 1064 return (-1); 1065 } 1066 1067 if (smb_idmap_getsid(id, idtype, &sid) != IDMAP_SUCCESS) 1068 return (-1); 1069 1070 smb_sid_tostr(sid, sidstr); 1071 smb_sid_free(sid); 1072 1073 return (0); 1074 } 1075 1076 /* 1077 * smb_quota_zfs_init 1078 * 1079 * Initialize zfs library and dataset handles 1080 */ 1081 static uint32_t 1082 smb_quota_zfs_init(const char *path, smb_quota_zfs_handle_t *zfs_hdl) 1083 { 1084 char dataset[MAXPATHLEN]; 1085 1086 if (smb_getdataset(path, dataset, MAXPATHLEN) != 0) 1087 return (NT_STATUS_INVALID_PARAMETER); 1088 1089 if ((zfs_hdl->z_lib = libzfs_init()) == NULL) 1090 return (NT_STATUS_INTERNAL_ERROR); 1091 1092 zfs_hdl->z_fs = zfs_open(zfs_hdl->z_lib, dataset, ZFS_TYPE_DATASET); 1093 if (zfs_hdl->z_fs == NULL) { 1094 libzfs_fini(zfs_hdl->z_lib); 1095 return (NT_STATUS_ACCESS_DENIED); 1096 } 1097 1098 return (NT_STATUS_SUCCESS); 1099 } 1100 1101 /* 1102 * smb_quota_zfs_fini 1103 * 1104 * Close zfs library and dataset handles 1105 */ 1106 static void 1107 smb_quota_zfs_fini(smb_quota_zfs_handle_t *zfs_hdl) 1108 { 1109 zfs_close(zfs_hdl->z_fs); 1110 libzfs_fini(zfs_hdl->z_lib); 1111 } 1112 1113 /* 1114 * smb_quota_add_ctrldir 1115 * 1116 * In order to display the quota properties tab, windows clients 1117 * check for the existence of the quota control file, created 1118 * here as follows: 1119 * - Create SMB_QUOTA_CNTRL_DIR directory (with A_HIDDEN & A_SYSTEM 1120 * attributes). 1121 * - Create the SMB_QUOTA_CNTRL_FILE file (with extended attribute 1122 * SMB_QUOTA_CNTRL_INDEX_XATTR) in the SMB_QUOTA_CNTRL_DIR directory. 1123 * - Set the acl of SMB_QUOTA_CNTRL_FILE file to SMB_QUOTA_CNTRL_PERM. 1124 */ 1125 static void 1126 smb_quota_add_ctrldir(const char *path) 1127 { 1128 int newfd, dirfd, afd; 1129 nvlist_t *attr; 1130 char dir[MAXPATHLEN], file[MAXPATHLEN], *acl_text; 1131 acl_t *aclp, *existing_aclp; 1132 boolean_t qdir_created, prop_hidden = B_FALSE, prop_sys = B_FALSE; 1133 struct stat statbuf; 1134 1135 assert(path != NULL); 1136 1137 (void) snprintf(dir, MAXPATHLEN, ".%s/%s", path, SMB_QUOTA_CNTRL_DIR); 1138 (void) snprintf(file, MAXPATHLEN, "%s/%s", dir, SMB_QUOTA_CNTRL_FILE); 1139 if ((mkdir(dir, 0750) < 0) && (errno != EEXIST)) 1140 return; 1141 qdir_created = (errno == EEXIST) ? B_FALSE : B_TRUE; 1142 1143 if ((dirfd = open(dir, O_RDONLY)) < 0) { 1144 if (qdir_created) 1145 (void) remove(dir); 1146 return; 1147 } 1148 1149 if (fgetattr(dirfd, XATTR_VIEW_READWRITE, &attr) != 0) { 1150 (void) close(dirfd); 1151 if (qdir_created) 1152 (void) remove(dir); 1153 return; 1154 } 1155 1156 if ((nvlist_lookup_boolean_value(attr, A_HIDDEN, &prop_hidden) != 0) || 1157 (nvlist_lookup_boolean_value(attr, A_SYSTEM, &prop_sys) != 0)) { 1158 nvlist_free(attr); 1159 (void) close(dirfd); 1160 if (qdir_created) 1161 (void) remove(dir); 1162 return; 1163 } 1164 nvlist_free(attr); 1165 1166 /* 1167 * Before setting attr or acl we check if the they have already been 1168 * set to what we want. If so we could be dealing with a received 1169 * snapshot and setting these is not needed. 1170 */ 1171 1172 if (!prop_hidden || !prop_sys) { 1173 if (nvlist_alloc(&attr, NV_UNIQUE_NAME, 0) == 0) { 1174 if ((nvlist_add_boolean_value( 1175 attr, A_HIDDEN, 1) != 0) || 1176 (nvlist_add_boolean_value( 1177 attr, A_SYSTEM, 1) != 0) || 1178 (fsetattr(dirfd, XATTR_VIEW_READWRITE, attr))) { 1179 nvlist_free(attr); 1180 (void) close(dirfd); 1181 if (qdir_created) 1182 (void) remove(dir); 1183 return; 1184 } 1185 } 1186 nvlist_free(attr); 1187 } 1188 1189 (void) close(dirfd); 1190 1191 if (stat(file, &statbuf) != 0) { 1192 if ((newfd = creat(file, 0640)) < 0) { 1193 if (qdir_created) 1194 (void) remove(dir); 1195 return; 1196 } 1197 (void) close(newfd); 1198 } 1199 1200 afd = attropen(file, SMB_QUOTA_CNTRL_INDEX_XATTR, O_RDWR | O_CREAT, 1201 0640); 1202 if (afd == -1) { 1203 (void) unlink(file); 1204 if (qdir_created) 1205 (void) remove(dir); 1206 return; 1207 } 1208 (void) close(afd); 1209 1210 if (acl_get(file, 0, &existing_aclp) == -1) { 1211 (void) unlink(file); 1212 if (qdir_created) 1213 (void) remove(dir); 1214 return; 1215 } 1216 1217 acl_text = acl_totext(existing_aclp, ACL_COMPACT_FMT); 1218 acl_free(existing_aclp); 1219 if (acl_text == NULL) { 1220 (void) unlink(file); 1221 if (qdir_created) 1222 (void) remove(dir); 1223 return; 1224 } 1225 1226 aclp = NULL; 1227 if (strcmp(acl_text, SMB_QUOTA_CNTRL_PERM) != 0) { 1228 if (acl_fromtext(SMB_QUOTA_CNTRL_PERM, &aclp) != 0) { 1229 free(acl_text); 1230 (void) unlink(file); 1231 if (qdir_created) 1232 (void) remove(dir); 1233 return; 1234 } 1235 if (acl_set(file, aclp) == -1) { 1236 free(acl_text); 1237 (void) unlink(file); 1238 if (qdir_created) 1239 (void) remove(dir); 1240 acl_free(aclp); 1241 return; 1242 } 1243 acl_free(aclp); 1244 } 1245 free(acl_text); 1246 } 1247 1248 /* 1249 * smb_quota_remove_ctrldir 1250 * 1251 * Remove SMB_QUOTA_CNTRL_FILE and SMB_QUOTA_CNTRL_DIR. 1252 */ 1253 static void 1254 smb_quota_remove_ctrldir(const char *path) 1255 { 1256 char dir[MAXPATHLEN], file[MAXPATHLEN]; 1257 assert(path); 1258 1259 (void) snprintf(dir, MAXPATHLEN, ".%s/%s", path, SMB_QUOTA_CNTRL_DIR); 1260 (void) snprintf(file, MAXPATHLEN, "%s/%s", dir, SMB_QUOTA_CNTRL_FILE); 1261 (void) unlink(file); 1262 (void) remove(dir); 1263 } 1264