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 }