1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2013 Nexenta Systems, Inc. All rights reserved. 24 * Copyright 2015 Joyent, Inc. 25 */ 26 27 #include <smbsrv/smb_kproto.h> 28 #include <smbsrv/smb_fsops.h> 29 #include <sys/sdt.h> 30 #include <sys/fcntl.h> 31 #include <sys/vfs.h> 32 #include <sys/vfs_opreg.h> 33 #include <sys/vnode.h> 34 #include <sys/fem.h> 35 36 extern caller_context_t smb_ct; 37 38 static boolean_t smb_fem_initialized = B_FALSE; 39 static fem_t *smb_fcn_ops = NULL; 40 static fem_t *smb_oplock_ops = NULL; 41 42 /* 43 * Declarations for FCN (file change notification) FEM monitors 44 */ 45 46 static int smb_fem_fcn_create(femarg_t *, char *, vattr_t *, vcexcl_t, int, 47 vnode_t **, cred_t *, int, caller_context_t *, vsecattr_t *); 48 static int smb_fem_fcn_remove(femarg_t *, char *, cred_t *, 49 caller_context_t *, int); 50 static int smb_fem_fcn_rename(femarg_t *, char *, vnode_t *, char *, 51 cred_t *, caller_context_t *, int); 52 static int smb_fem_fcn_mkdir(femarg_t *, char *, vattr_t *, vnode_t **, 53 cred_t *, caller_context_t *, int, vsecattr_t *); 54 static int smb_fem_fcn_rmdir(femarg_t *, char *, vnode_t *, cred_t *, 55 caller_context_t *, int); 56 static int smb_fem_fcn_link(femarg_t *, vnode_t *, char *, cred_t *, 57 caller_context_t *, int); 58 static int smb_fem_fcn_symlink(femarg_t *, char *, vattr_t *, 59 char *, cred_t *, caller_context_t *, int); 60 61 static const fs_operation_def_t smb_fcn_tmpl[] = { 62 VOPNAME_CREATE, { .femop_create = smb_fem_fcn_create }, 63 VOPNAME_REMOVE, {.femop_remove = smb_fem_fcn_remove}, 64 VOPNAME_RENAME, {.femop_rename = smb_fem_fcn_rename}, 65 VOPNAME_MKDIR, {.femop_mkdir = smb_fem_fcn_mkdir}, 66 VOPNAME_RMDIR, {.femop_rmdir = smb_fem_fcn_rmdir}, 67 VOPNAME_LINK, {.femop_link = smb_fem_fcn_link}, 68 VOPNAME_SYMLINK, {.femop_symlink = smb_fem_fcn_symlink}, 69 NULL, NULL 70 }; 71 72 /* 73 * Declarations for oplock FEM monitors 74 */ 75 76 static int smb_fem_oplock_open(femarg_t *, int, cred_t *, 77 struct caller_context *); 78 static int smb_fem_oplock_read(femarg_t *, uio_t *, int, cred_t *, 79 struct caller_context *); 80 static int smb_fem_oplock_write(femarg_t *, uio_t *, int, cred_t *, 81 struct caller_context *); 82 static int smb_fem_oplock_setattr(femarg_t *, vattr_t *, int, cred_t *, 83 caller_context_t *); 84 static int smb_fem_oplock_rwlock(femarg_t *, int, caller_context_t *); 85 static int smb_fem_oplock_space(femarg_t *, int, flock64_t *, int, 86 offset_t, cred_t *, caller_context_t *); 87 static int smb_fem_oplock_vnevent(femarg_t *, vnevent_t, vnode_t *, char *, 88 caller_context_t *); 89 90 static const fs_operation_def_t smb_oplock_tmpl[] = { 91 VOPNAME_OPEN, { .femop_open = smb_fem_oplock_open }, 92 VOPNAME_READ, { .femop_read = smb_fem_oplock_read }, 93 VOPNAME_WRITE, { .femop_write = smb_fem_oplock_write }, 94 VOPNAME_SETATTR, { .femop_setattr = smb_fem_oplock_setattr }, 95 VOPNAME_RWLOCK, { .femop_rwlock = smb_fem_oplock_rwlock }, 96 VOPNAME_SPACE, { .femop_space = smb_fem_oplock_space }, 97 VOPNAME_VNEVENT, { .femop_vnevent = smb_fem_oplock_vnevent }, 98 NULL, NULL 99 }; 100 101 static int smb_fem_oplock_break(femarg_t *, caller_context_t *, uint32_t); 102 103 /* 104 * smb_fem_init 105 * 106 * This function is not multi-thread safe. The caller must make sure only one 107 * thread makes the call. 108 */ 109 int 110 smb_fem_init(void) 111 { 112 int rc = 0; 113 114 if (smb_fem_initialized) 115 return (0); 116 117 rc = fem_create("smb_fcn_ops", smb_fcn_tmpl, &smb_fcn_ops); 118 if (rc) 119 return (rc); 120 121 rc = fem_create("smb_oplock_ops", smb_oplock_tmpl, 122 &smb_oplock_ops); 123 124 if (rc) { 125 fem_free(smb_fcn_ops); 126 smb_fcn_ops = NULL; 127 return (rc); 128 } 129 130 smb_fem_initialized = B_TRUE; 131 132 return (0); 133 } 134 135 /* 136 * smb_fem_fini 137 * 138 * This function is not multi-thread safe. The caller must make sure only one 139 * thread makes the call. 140 */ 141 void 142 smb_fem_fini(void) 143 { 144 if (!smb_fem_initialized) 145 return; 146 147 if (smb_fcn_ops != NULL) { 148 fem_free(smb_fcn_ops); 149 smb_fcn_ops = NULL; 150 } 151 if (smb_oplock_ops != NULL) { 152 fem_free(smb_oplock_ops); 153 smb_oplock_ops = NULL; 154 } 155 smb_fem_initialized = B_FALSE; 156 } 157 158 int 159 smb_fem_fcn_install(smb_node_t *node) 160 { 161 int rc; 162 163 if (smb_fcn_ops == NULL) 164 return (ENOSYS); 165 rc = fem_install(node->vp, smb_fcn_ops, (void *)node, OPARGUNIQ, 166 (fem_func_t)smb_node_ref, (fem_func_t)smb_node_release); 167 return (rc); 168 } 169 170 void 171 smb_fem_fcn_uninstall(smb_node_t *node) 172 { 173 if (smb_fcn_ops == NULL) 174 return; 175 VERIFY0(fem_uninstall(node->vp, smb_fcn_ops, (void *)node)); 176 } 177 178 int 179 smb_fem_oplock_install(smb_node_t *node) 180 { 181 int rc; 182 183 if (smb_oplock_ops == NULL) 184 return (ENOSYS); 185 rc = fem_install(node->vp, smb_oplock_ops, (void *)node, OPARGUNIQ, 186 (fem_func_t)smb_node_ref, (fem_func_t)smb_node_release); 187 return (rc); 188 } 189 190 void 191 smb_fem_oplock_uninstall(smb_node_t *node) 192 { 193 if (smb_oplock_ops == NULL) 194 return; 195 VERIFY0(fem_uninstall(node->vp, smb_oplock_ops, (void *)node)); 196 } 197 198 /* 199 * FEM FCN monitors 200 * 201 * The FCN monitors intercept the respective VOP_* call regardless 202 * of whether the call originates from CIFS, NFS, or a local process. 203 */ 204 205 /* 206 * smb_fem_fcn_create() 207 * 208 * This monitor will catch only changes to VREG files and not to extended 209 * attribute files. This is fine because, for CIFS files, stream creates 210 * should not trigger any file change notification on the VDIR directory 211 * being monitored. Creates of any other kind of extended attribute in 212 * the directory will also not trigger any file change notification on the 213 * VDIR directory being monitored. 214 */ 215 216 static int 217 smb_fem_fcn_create( 218 femarg_t *arg, 219 char *name, 220 vattr_t *vap, 221 vcexcl_t excl, 222 int mode, 223 vnode_t **vpp, 224 cred_t *cr, 225 int flag, 226 caller_context_t *ct, 227 vsecattr_t *vsecp) 228 { 229 smb_node_t *dnode; 230 int error; 231 232 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 233 234 ASSERT(dnode); 235 236 error = vnext_create(arg, name, vap, excl, mode, vpp, cr, flag, 237 ct, vsecp); 238 239 if (error == 0 && ct != &smb_ct) 240 smb_node_notify_change(dnode, FILE_ACTION_ADDED, name); 241 242 return (error); 243 } 244 245 /* 246 * smb_fem_fcn_remove() 247 * 248 * This monitor will catch only changes to VREG files and to not extended 249 * attribute files. This is fine because, for CIFS files, stream deletes 250 * should not trigger any file change notification on the VDIR directory 251 * being monitored. Deletes of any other kind of extended attribute in 252 * the directory will also not trigger any file change notification on the 253 * VDIR directory being monitored. 254 */ 255 256 static int 257 smb_fem_fcn_remove( 258 femarg_t *arg, 259 char *name, 260 cred_t *cr, 261 caller_context_t *ct, 262 int flags) 263 { 264 smb_node_t *dnode; 265 int error; 266 267 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 268 269 ASSERT(dnode); 270 271 error = vnext_remove(arg, name, cr, ct, flags); 272 273 if (error == 0 && ct != &smb_ct) 274 smb_node_notify_change(dnode, FILE_ACTION_REMOVED, name); 275 276 return (error); 277 } 278 279 static int 280 smb_fem_fcn_rename( 281 femarg_t *arg, 282 char *snm, 283 vnode_t *tdvp, 284 char *tnm, 285 cred_t *cr, 286 caller_context_t *ct, 287 int flags) 288 { 289 smb_node_t *dnode; 290 int error; 291 292 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 293 294 ASSERT(dnode); 295 296 error = vnext_rename(arg, snm, tdvp, tnm, cr, ct, flags); 297 298 if (error == 0 && ct != &smb_ct) { 299 /* 300 * Note that renames in the same directory are normally 301 * delivered in {old,new} pairs, and clients expect them 302 * in that order, if both events are delivered. 303 */ 304 smb_node_notify_change(dnode, 305 FILE_ACTION_RENAMED_OLD_NAME, snm); 306 smb_node_notify_change(dnode, 307 FILE_ACTION_RENAMED_NEW_NAME, tnm); 308 } 309 310 return (error); 311 } 312 313 static int 314 smb_fem_fcn_mkdir( 315 femarg_t *arg, 316 char *name, 317 vattr_t *vap, 318 vnode_t **vpp, 319 cred_t *cr, 320 caller_context_t *ct, 321 int flags, 322 vsecattr_t *vsecp) 323 { 324 smb_node_t *dnode; 325 int error; 326 327 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 328 329 ASSERT(dnode); 330 331 error = vnext_mkdir(arg, name, vap, vpp, cr, ct, flags, vsecp); 332 333 if (error == 0 && ct != &smb_ct) 334 smb_node_notify_change(dnode, FILE_ACTION_ADDED, name); 335 336 return (error); 337 } 338 339 static int 340 smb_fem_fcn_rmdir( 341 femarg_t *arg, 342 char *name, 343 vnode_t *cdir, 344 cred_t *cr, 345 caller_context_t *ct, 346 int flags) 347 { 348 smb_node_t *dnode; 349 int error; 350 351 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 352 353 ASSERT(dnode); 354 355 error = vnext_rmdir(arg, name, cdir, cr, ct, flags); 356 357 if (error == 0 && ct != &smb_ct) 358 smb_node_notify_change(dnode, FILE_ACTION_REMOVED, name); 359 360 return (error); 361 } 362 363 static int 364 smb_fem_fcn_link( 365 femarg_t *arg, 366 vnode_t *svp, 367 char *tnm, 368 cred_t *cr, 369 caller_context_t *ct, 370 int flags) 371 { 372 smb_node_t *dnode; 373 int error; 374 375 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 376 377 ASSERT(dnode); 378 379 error = vnext_link(arg, svp, tnm, cr, ct, flags); 380 381 if (error == 0 && ct != &smb_ct) 382 smb_node_notify_change(dnode, FILE_ACTION_ADDED, tnm); 383 384 return (error); 385 } 386 387 static int 388 smb_fem_fcn_symlink( 389 femarg_t *arg, 390 char *linkname, 391 vattr_t *vap, 392 char *target, 393 cred_t *cr, 394 caller_context_t *ct, 395 int flags) 396 { 397 smb_node_t *dnode; 398 int error; 399 400 dnode = (smb_node_t *)arg->fa_fnode->fn_available; 401 402 ASSERT(dnode); 403 404 error = vnext_symlink(arg, linkname, vap, target, cr, ct, flags); 405 406 if (error == 0 && ct != &smb_ct) 407 smb_node_notify_change(dnode, FILE_ACTION_ADDED, linkname); 408 409 return (error); 410 } 411 412 /* 413 * FEM oplock monitors 414 * 415 * The monitors below are not intended to intercept CIFS calls. 416 * CIFS higher-level routines will break oplocks as needed prior 417 * to getting to the VFS layer. 418 */ 419 static int 420 smb_fem_oplock_open( 421 femarg_t *arg, 422 int mode, 423 cred_t *cr, 424 caller_context_t *ct) 425 { 426 uint32_t flags; 427 int rc = 0; 428 429 if (ct != &smb_ct) { 430 if (mode & (FWRITE|FTRUNC)) 431 flags = SMB_OPLOCK_BREAK_TO_NONE; 432 else 433 flags = SMB_OPLOCK_BREAK_TO_LEVEL_II; 434 rc = smb_fem_oplock_break(arg, ct, flags); 435 } 436 if (rc == 0) 437 rc = vnext_open(arg, mode, cr, ct); 438 439 return (rc); 440 } 441 442 /* 443 * Should normally be hit only via NFSv2/v3. All other accesses 444 * (CIFS/NFS/local) should call VOP_OPEN first. 445 */ 446 447 static int 448 smb_fem_oplock_read( 449 femarg_t *arg, 450 uio_t *uiop, 451 int ioflag, 452 cred_t *cr, 453 caller_context_t *ct) 454 { 455 int rc = 0; 456 457 if (ct != &smb_ct) { 458 rc = smb_fem_oplock_break(arg, ct, 459 SMB_OPLOCK_BREAK_TO_LEVEL_II); 460 } 461 if (rc == 0) 462 rc = vnext_read(arg, uiop, ioflag, cr, ct); 463 464 return (rc); 465 } 466 467 /* 468 * Should normally be hit only via NFSv2/v3. All other accesses 469 * (CIFS/NFS/local) should call VOP_OPEN first. 470 */ 471 472 static int 473 smb_fem_oplock_write( 474 femarg_t *arg, 475 uio_t *uiop, 476 int ioflag, 477 cred_t *cr, 478 caller_context_t *ct) 479 { 480 int rc = 0; 481 482 if (ct != &smb_ct) 483 rc = smb_fem_oplock_break(arg, ct, SMB_OPLOCK_BREAK_TO_NONE); 484 if (rc == 0) 485 rc = vnext_write(arg, uiop, ioflag, cr, ct); 486 487 return (rc); 488 } 489 490 static int 491 smb_fem_oplock_setattr( 492 femarg_t *arg, 493 vattr_t *vap, 494 int flags, 495 cred_t *cr, 496 caller_context_t *ct) 497 { 498 int rc = 0; 499 500 if (ct != &smb_ct && (vap->va_mask & AT_SIZE) != 0) 501 rc = smb_fem_oplock_break(arg, ct, SMB_OPLOCK_BREAK_TO_NONE); 502 if (rc == 0) 503 rc = vnext_setattr(arg, vap, flags, cr, ct); 504 return (rc); 505 } 506 507 static int 508 smb_fem_oplock_rwlock( 509 femarg_t *arg, 510 int write_lock, 511 caller_context_t *ct) 512 { 513 uint32_t flags; 514 int rc = 0; 515 516 if (ct != &smb_ct) { 517 if (write_lock) 518 flags = SMB_OPLOCK_BREAK_TO_NONE; 519 else 520 flags = SMB_OPLOCK_BREAK_TO_LEVEL_II; 521 rc = smb_fem_oplock_break(arg, ct, flags); 522 } 523 if (rc == 0) 524 rc = vnext_rwlock(arg, write_lock, ct); 525 526 return (rc); 527 } 528 529 static int 530 smb_fem_oplock_space( 531 femarg_t *arg, 532 int cmd, 533 flock64_t *bfp, 534 int flag, 535 offset_t offset, 536 cred_t *cr, 537 caller_context_t *ct) 538 { 539 int rc = 0; 540 541 if (ct != &smb_ct) 542 rc = smb_fem_oplock_break(arg, ct, SMB_OPLOCK_BREAK_TO_NONE); 543 if (rc == 0) 544 rc = vnext_space(arg, cmd, bfp, flag, offset, cr, ct); 545 return (rc); 546 } 547 548 /* 549 * smb_fem_oplock_vnevent() 550 * 551 * To intercept NFS and local renames and removes in order to break any 552 * existing oplock prior to the operation. 553 * 554 * Note: Currently, this monitor is traversed only when an FS is mounted 555 * non-nbmand. (When the FS is mounted nbmand, share reservation checking 556 * will detect a share violation and return an error prior to the VOP layer 557 * being reached.) Thus, for nbmand NFS and local renames and removes, 558 * an existing oplock is never broken prior to share checking (contrary to 559 * how it is with intra-CIFS remove and rename requests). 560 */ 561 562 static int 563 smb_fem_oplock_vnevent( 564 femarg_t *arg, 565 vnevent_t vnevent, 566 vnode_t *dvp, 567 char *name, 568 caller_context_t *ct) 569 { 570 uint32_t flags; 571 int rc = 0; 572 573 if (ct != &smb_ct) { 574 switch (vnevent) { 575 case VE_REMOVE: 576 case VE_PRE_RENAME_DEST: 577 case VE_RENAME_DEST: 578 flags = SMB_OPLOCK_BREAK_TO_NONE | 579 SMB_OPLOCK_BREAK_BATCH; 580 rc = smb_fem_oplock_break(arg, ct, flags); 581 break; 582 case VE_PRE_RENAME_SRC: 583 case VE_RENAME_SRC: 584 flags = SMB_OPLOCK_BREAK_TO_LEVEL_II | 585 SMB_OPLOCK_BREAK_BATCH; 586 rc = smb_fem_oplock_break(arg, ct, flags); 587 break; 588 default: 589 rc = 0; 590 break; 591 } 592 } 593 if (rc == 0) 594 rc = vnext_vnevent(arg, vnevent, dvp, name, ct); 595 596 return (rc); 597 } 598 599 static int 600 smb_fem_oplock_break(femarg_t *arg, caller_context_t *ct, uint32_t flags) 601 { 602 smb_node_t *node; 603 int rc; 604 605 node = (smb_node_t *)((arg)->fa_fnode->fn_available); 606 SMB_NODE_VALID(node); 607 608 ASSERT(ct != &smb_ct); 609 610 if (ct && (ct->cc_flags & CC_DONTBLOCK)) { 611 flags |= SMB_OPLOCK_BREAK_NOWAIT; 612 rc = smb_oplock_break(NULL, node, flags); 613 if (rc == EAGAIN) 614 ct->cc_flags |= CC_WOULDBLOCK; 615 } else { 616 rc = smb_oplock_break(NULL, node, flags); 617 } 618 619 return (rc); 620 } 621