module/os/linux/zfs/zpl_ctldir.c

   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) 2011 Lawrence Livermore National Security, LLC.
  23  * Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
  24  * LLNL-CODE-403049.
  25  * Rewritten for Linux by:
  26  *   Rohan Puri <rohan.puri15@gmail.com>
  27  *   Brian Behlendorf <behlendorf1@llnl.gov>
  28  */
  29
  30 #include <sys/zfs_znode.h>
  31 #include <sys/zfs_vfsops.h>
  32 #include <sys/zfs_vnops.h>
  33 #include <sys/zfs_ctldir.h>
  34 #include <sys/zpl.h>
  35
  36 /*
  37  * Common open routine.  Disallow any write access.
  38  */
  39 static int
  40 zpl_common_open(struct inode *ip, struct file *filp)
  41 {
  42         if (filp->f_mode & FMODE_WRITE)
  43                 return (-EACCES);
  44
  45         return (generic_file_open(ip, filp));
  46 }
  47
  48 /*
  49  * Get root directory contents.
  50  */
  51 static int
  52 zpl_root_iterate(struct file *filp, zpl_dir_context_t *ctx)
  53 {
  54         zfsvfs_t *zfsvfs = ITOZSB(file_inode(filp));
  55         int error = 0;
  56
  57         ZPL_ENTER(zfsvfs);
  58
  59         if (!zpl_dir_emit_dots(filp, ctx))
  60                 goto out;
  61
  62         if (ctx->pos == 2) {
  63                 if (!zpl_dir_emit(ctx, ZFS_SNAPDIR_NAME,
  64                     strlen(ZFS_SNAPDIR_NAME), ZFSCTL_INO_SNAPDIR, DT_DIR))
  65                         goto out;
  66
  67                 ctx->pos++;
  68         }
  69
  70         if (ctx->pos == 3) {
  71                 if (!zpl_dir_emit(ctx, ZFS_SHAREDIR_NAME,
  72                     strlen(ZFS_SHAREDIR_NAME), ZFSCTL_INO_SHARES, DT_DIR))
  73                         goto out;
  74
  75                 ctx->pos++;
  76         }
  77 out:
  78         ZPL_EXIT(zfsvfs);
  79
  80         return (error);
  81 }
  82
  83 #if !defined(HAVE_VFS_ITERATE) && !defined(HAVE_VFS_ITERATE_SHARED)
  84 static int
  85 zpl_root_readdir(struct file *filp, void *dirent, filldir_t filldir)
  86 {
  87         zpl_dir_context_t ctx =
  88             ZPL_DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
  89         int error;
  90
  91         error = zpl_root_iterate(filp, &ctx);
  92         filp->f_pos = ctx.pos;
  93
  94         return (error);
  95 }
  96 #endif /* !HAVE_VFS_ITERATE && !HAVE_VFS_ITERATE_SHARED */
  97
  98 /*
  99  * Get root directory attributes.
 100  */
 101 static int
 102 #ifdef HAVE_USERNS_IOPS_GETATTR
 103 zpl_root_getattr_impl(struct user_namespace *user_ns,
 104     const struct path *path, struct kstat *stat, u32 request_mask,
 105     unsigned int query_flags)
 106 #else
 107 zpl_root_getattr_impl(const struct path *path, struct kstat *stat,
 108     u32 request_mask, unsigned int query_flags)
 109 #endif
 110 {
 111         (void) request_mask, (void) query_flags;
 112         struct inode *ip = path->dentry->d_inode;
 113
 114 #ifdef HAVE_USERNS_IOPS_GETATTR
 115 #ifdef HAVE_GENERIC_FILLATTR_USERNS
 116         generic_fillattr(user_ns, ip, stat);
 117 #else
 118         (void) user_ns;
 119 #endif
 120 #else
 121         generic_fillattr(ip, stat);
 122 #endif
 123         stat->atime = current_time(ip);
 124
 125         return (0);
 126 }
 127 ZPL_GETATTR_WRAPPER(zpl_root_getattr);
 128
 129 static struct dentry *
 130 zpl_root_lookup(struct inode *dip, struct dentry *dentry, unsigned int flags)
 131 {
 132         cred_t *cr = CRED();
 133         struct inode *ip;
 134         int error;
 135
 136         crhold(cr);
 137         error = -zfsctl_root_lookup(dip, dname(dentry), &ip, 0, cr, NULL, NULL);
 138         ASSERT3S(error, <=, 0);
 139         crfree(cr);
 140
 141         if (error) {
 142                 if (error == -ENOENT)
 143                         return (d_splice_alias(NULL, dentry));
 144                 else
 145                         return (ERR_PTR(error));
 146         }
 147
 148         return (d_splice_alias(ip, dentry));
 149 }
 150
 151 /*
 152  * The '.zfs' control directory file and inode operations.
 153  */
 154 const struct file_operations zpl_fops_root = {
 155         .open           = zpl_common_open,
 156         .llseek         = generic_file_llseek,
 157         .read           = generic_read_dir,
 158 #ifdef HAVE_VFS_ITERATE_SHARED
 159         .iterate_shared = zpl_root_iterate,
 160 #elif defined(HAVE_VFS_ITERATE)
 161         .iterate        = zpl_root_iterate,
 162 #else
 163         .readdir        = zpl_root_readdir,
 164 #endif
 165 };
 166
 167 const struct inode_operations zpl_ops_root = {
 168         .lookup         = zpl_root_lookup,
 169         .getattr        = zpl_root_getattr,
 170 };
 171
 172 static struct vfsmount *
 173 zpl_snapdir_automount(struct path *path)
 174 {
 175         int error;
 176
 177         error = -zfsctl_snapshot_mount(path, 0);
 178         if (error)
 179                 return (ERR_PTR(error));
 180
 181         /*
 182          * Rather than returning the new vfsmount for the snapshot we must
 183          * return NULL to indicate a mount collision.  This is done because
 184          * the user space mount calls do_add_mount() which adds the vfsmount
 185          * to the name space.  If we returned the new mount here it would be
 186          * added again to the vfsmount list resulting in list corruption.
 187          */
 188         return (NULL);
 189 }
 190
 191 /*
 192  * Negative dentries must always be revalidated so newly created snapshots
 193  * can be detected and automounted.  Normal dentries should be kept because
 194  * as of the 3.18 kernel revaliding the mountpoint dentry will result in
 195  * the snapshot being immediately unmounted.
 196  */
 197 static int
 198 #ifdef HAVE_D_REVALIDATE_NAMEIDATA
 199 zpl_snapdir_revalidate(struct dentry *dentry, struct nameidata *i)
 200 #else
 201 zpl_snapdir_revalidate(struct dentry *dentry, unsigned int flags)
 202 #endif
 203 {
 204         return (!!dentry->d_inode);
 205 }
 206
 207 static const dentry_operations_t zpl_dops_snapdirs = {
 208 /*
 209  * Auto mounting of snapshots is only supported for 2.6.37 and
 210  * newer kernels.  Prior to this kernel the ops->follow_link()
 211  * callback was used as a hack to trigger the mount.  The
 212  * resulting vfsmount was then explicitly grafted in to the
 213  * name space.  While it might be possible to add compatibility
 214  * code to accomplish this it would require considerable care.
 215  */
 216         .d_automount    = zpl_snapdir_automount,
 217         .d_revalidate   = zpl_snapdir_revalidate,
 218 };
 219
 220 static struct dentry *
 221 zpl_snapdir_lookup(struct inode *dip, struct dentry *dentry,
 222     unsigned int flags)
 223 {
 224         fstrans_cookie_t cookie;
 225         cred_t *cr = CRED();
 226         struct inode *ip = NULL;
 227         int error;
 228
 229         crhold(cr);
 230         cookie = spl_fstrans_mark();
 231         error = -zfsctl_snapdir_lookup(dip, dname(dentry), &ip,
 232             0, cr, NULL, NULL);
 233         ASSERT3S(error, <=, 0);
 234         spl_fstrans_unmark(cookie);
 235         crfree(cr);
 236
 237         if (error && error != -ENOENT)
 238                 return (ERR_PTR(error));
 239
 240         ASSERT(error == 0 || ip == NULL);
 241         d_clear_d_op(dentry);
 242         d_set_d_op(dentry, &zpl_dops_snapdirs);
 243         dentry->d_flags |= DCACHE_NEED_AUTOMOUNT;
 244
 245         return (d_splice_alias(ip, dentry));
 246 }
 247
 248 static int
 249 zpl_snapdir_iterate(struct file *filp, zpl_dir_context_t *ctx)
 250 {
 251         zfsvfs_t *zfsvfs = ITOZSB(file_inode(filp));
 252         fstrans_cookie_t cookie;
 253         char snapname[MAXNAMELEN];
 254         boolean_t case_conflict;
 255         uint64_t id, pos;
 256         int error = 0;
 257
 258         ZPL_ENTER(zfsvfs);
 259         cookie = spl_fstrans_mark();
 260
 261         if (!zpl_dir_emit_dots(filp, ctx))
 262                 goto out;
 263
 264         /* Start the position at 0 if it already emitted . and .. */
 265         pos = (ctx->pos == 2 ? 0 : ctx->pos);
 266         while (error == 0) {
 267                 dsl_pool_config_enter(dmu_objset_pool(zfsvfs->z_os), FTAG);
 268                 error = -dmu_snapshot_list_next(zfsvfs->z_os, MAXNAMELEN,
 269                     snapname, &id, &pos, &case_conflict);
 270                 dsl_pool_config_exit(dmu_objset_pool(zfsvfs->z_os), FTAG);
 271                 if (error)
 272                         goto out;
 273
 274                 if (!zpl_dir_emit(ctx, snapname, strlen(snapname),
 275                     ZFSCTL_INO_SHARES - id, DT_DIR))
 276                         goto out;
 277
 278                 ctx->pos = pos;
 279         }
 280 out:
 281         spl_fstrans_unmark(cookie);
 282         ZPL_EXIT(zfsvfs);
 283
 284         if (error == -ENOENT)
 285                 return (0);
 286
 287         return (error);
 288 }
 289
 290 #if !defined(HAVE_VFS_ITERATE) && !defined(HAVE_VFS_ITERATE_SHARED)
 291 static int
 292 zpl_snapdir_readdir(struct file *filp, void *dirent, filldir_t filldir)
 293 {
 294         zpl_dir_context_t ctx =
 295             ZPL_DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
 296         int error;
 297
 298         error = zpl_snapdir_iterate(filp, &ctx);
 299         filp->f_pos = ctx.pos;
 300
 301         return (error);
 302 }
 303 #endif /* !HAVE_VFS_ITERATE && !HAVE_VFS_ITERATE_SHARED */
 304
 305 static int
 306 #ifdef HAVE_IOPS_RENAME_USERNS
 307 zpl_snapdir_rename2(struct user_namespace *user_ns, struct inode *sdip,
 308     struct dentry *sdentry, struct inode *tdip, struct dentry *tdentry,
 309     unsigned int flags)
 310 #else
 311 zpl_snapdir_rename2(struct inode *sdip, struct dentry *sdentry,
 312     struct inode *tdip, struct dentry *tdentry, unsigned int flags)
 313 #endif
 314 {
 315         cred_t *cr = CRED();
 316         int error;
 317
 318         /* We probably don't want to support renameat2(2) in ctldir */
 319         if (flags)
 320                 return (-EINVAL);
 321
 322         crhold(cr);
 323         error = -zfsctl_snapdir_rename(sdip, dname(sdentry),
 324             tdip, dname(tdentry), cr, 0);
 325         ASSERT3S(error, <=, 0);
 326         crfree(cr);
 327
 328         return (error);
 329 }
 330
 331 #if !defined(HAVE_RENAME_WANTS_FLAGS) && !defined(HAVE_IOPS_RENAME_USERNS)
 332 static int
 333 zpl_snapdir_rename(struct inode *sdip, struct dentry *sdentry,
 334     struct inode *tdip, struct dentry *tdentry)
 335 {
 336         return (zpl_snapdir_rename2(sdip, sdentry, tdip, tdentry, 0));
 337 }
 338 #endif
 339
 340 static int
 341 zpl_snapdir_rmdir(struct inode *dip, struct dentry *dentry)
 342 {
 343         cred_t *cr = CRED();
 344         int error;
 345
 346         crhold(cr);
 347         error = -zfsctl_snapdir_remove(dip, dname(dentry), cr, 0);
 348         ASSERT3S(error, <=, 0);
 349         crfree(cr);
 350
 351         return (error);
 352 }
 353
 354 static int
 355 #ifdef HAVE_IOPS_MKDIR_USERNS
 356 zpl_snapdir_mkdir(struct user_namespace *user_ns, struct inode *dip,
 357     struct dentry *dentry, umode_t mode)
 358 #else
 359 zpl_snapdir_mkdir(struct inode *dip, struct dentry *dentry, umode_t mode)
 360 #endif
 361 {
 362         cred_t *cr = CRED();
 363         vattr_t *vap;
 364         struct inode *ip;
 365         int error;
 366
 367         crhold(cr);
 368         vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
 369         zpl_vap_init(vap, dip, mode | S_IFDIR, cr);
 370
 371         error = -zfsctl_snapdir_mkdir(dip, dname(dentry), vap, &ip, cr, 0);
 372         if (error == 0) {
 373                 d_clear_d_op(dentry);
 374                 d_set_d_op(dentry, &zpl_dops_snapdirs);
 375                 d_instantiate(dentry, ip);
 376         }
 377
 378         kmem_free(vap, sizeof (vattr_t));
 379         ASSERT3S(error, <=, 0);
 380         crfree(cr);
 381
 382         return (error);
 383 }
 384
 385 /*
 386  * Get snapshot directory attributes.
 387  */
 388 static int
 389 #ifdef HAVE_USERNS_IOPS_GETATTR
 390 zpl_snapdir_getattr_impl(struct user_namespace *user_ns,
 391     const struct path *path, struct kstat *stat, u32 request_mask,
 392     unsigned int query_flags)
 393 #else
 394 zpl_snapdir_getattr_impl(const struct path *path, struct kstat *stat,
 395     u32 request_mask, unsigned int query_flags)
 396 #endif
 397 {
 398         (void) request_mask, (void) query_flags;
 399         struct inode *ip = path->dentry->d_inode;
 400         zfsvfs_t *zfsvfs = ITOZSB(ip);
 401
 402         ZPL_ENTER(zfsvfs);
 403 #ifdef HAVE_USERNS_IOPS_GETATTR
 404 #ifdef HAVE_GENERIC_FILLATTR_USERNS
 405         generic_fillattr(user_ns, ip, stat);
 406 #else
 407         (void) user_ns;
 408 #endif
 409 #else
 410         generic_fillattr(ip, stat);
 411 #endif
 412
 413         stat->nlink = stat->size = 2;
 414         stat->ctime = stat->mtime = dmu_objset_snap_cmtime(zfsvfs->z_os);
 415         stat->atime = current_time(ip);
 416         ZPL_EXIT(zfsvfs);
 417
 418         return (0);
 419 }
 420 ZPL_GETATTR_WRAPPER(zpl_snapdir_getattr);
 421
 422 /*
 423  * The '.zfs/snapshot' directory file operations.  These mainly control
 424  * generating the list of available snapshots when doing an 'ls' in the
 425  * directory.  See zpl_snapdir_readdir().
 426  */
 427 const struct file_operations zpl_fops_snapdir = {
 428         .open           = zpl_common_open,
 429         .llseek         = generic_file_llseek,
 430         .read           = generic_read_dir,
 431 #ifdef HAVE_VFS_ITERATE_SHARED
 432         .iterate_shared = zpl_snapdir_iterate,
 433 #elif defined(HAVE_VFS_ITERATE)
 434         .iterate        = zpl_snapdir_iterate,
 435 #else
 436         .readdir        = zpl_snapdir_readdir,
 437 #endif
 438
 439 };
 440
 441 /*
 442  * The '.zfs/snapshot' directory inode operations.  These mainly control
 443  * creating an inode for a snapshot directory and initializing the needed
 444  * infrastructure to automount the snapshot.  See zpl_snapdir_lookup().
 445  */
 446 const struct inode_operations zpl_ops_snapdir = {
 447         .lookup         = zpl_snapdir_lookup,
 448         .getattr        = zpl_snapdir_getattr,
 449 #if defined(HAVE_RENAME_WANTS_FLAGS) || defined(HAVE_IOPS_RENAME_USERNS)
 450         .rename         = zpl_snapdir_rename2,
 451 #else
 452         .rename         = zpl_snapdir_rename,
 453 #endif
 454         .rmdir          = zpl_snapdir_rmdir,
 455         .mkdir          = zpl_snapdir_mkdir,
 456 };
 457
 458 static struct dentry *
 459 zpl_shares_lookup(struct inode *dip, struct dentry *dentry,
 460     unsigned int flags)
 461 {
 462         fstrans_cookie_t cookie;
 463         cred_t *cr = CRED();
 464         struct inode *ip = NULL;
 465         int error;
 466
 467         crhold(cr);
 468         cookie = spl_fstrans_mark();
 469         error = -zfsctl_shares_lookup(dip, dname(dentry), &ip,
 470             0, cr, NULL, NULL);
 471         ASSERT3S(error, <=, 0);
 472         spl_fstrans_unmark(cookie);
 473         crfree(cr);
 474
 475         if (error) {
 476                 if (error == -ENOENT)
 477                         return (d_splice_alias(NULL, dentry));
 478                 else
 479                         return (ERR_PTR(error));
 480         }
 481
 482         return (d_splice_alias(ip, dentry));
 483 }
 484
 485 static int
 486 zpl_shares_iterate(struct file *filp, zpl_dir_context_t *ctx)
 487 {
 488         fstrans_cookie_t cookie;
 489         cred_t *cr = CRED();
 490         zfsvfs_t *zfsvfs = ITOZSB(file_inode(filp));
 491         znode_t *dzp;
 492         int error = 0;
 493
 494         ZPL_ENTER(zfsvfs);
 495         cookie = spl_fstrans_mark();
 496
 497         if (zfsvfs->z_shares_dir == 0) {
 498                 zpl_dir_emit_dots(filp, ctx);
 499                 goto out;
 500         }
 501
 502         error = -zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp);
 503         if (error)
 504                 goto out;
 505
 506         crhold(cr);
 507         error = -zfs_readdir(ZTOI(dzp), ctx, cr);
 508         crfree(cr);
 509
 510         iput(ZTOI(dzp));
 511 out:
 512         spl_fstrans_unmark(cookie);
 513         ZPL_EXIT(zfsvfs);
 514         ASSERT3S(error, <=, 0);
 515
 516         return (error);
 517 }
 518
 519 #if !defined(HAVE_VFS_ITERATE) && !defined(HAVE_VFS_ITERATE_SHARED)
 520 static int
 521 zpl_shares_readdir(struct file *filp, void *dirent, filldir_t filldir)
 522 {
 523         zpl_dir_context_t ctx =
 524             ZPL_DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
 525         int error;
 526
 527         error = zpl_shares_iterate(filp, &ctx);
 528         filp->f_pos = ctx.pos;
 529
 530         return (error);
 531 }
 532 #endif /* !HAVE_VFS_ITERATE && !HAVE_VFS_ITERATE_SHARED */
 533
 534 static int
 535 #ifdef HAVE_USERNS_IOPS_GETATTR
 536 zpl_shares_getattr_impl(struct user_namespace *user_ns,
 537     const struct path *path, struct kstat *stat, u32 request_mask,
 538     unsigned int query_flags)
 539 #else
 540 zpl_shares_getattr_impl(const struct path *path, struct kstat *stat,
 541     u32 request_mask, unsigned int query_flags)
 542 #endif
 543 {
 544         (void) request_mask, (void) query_flags;
 545         struct inode *ip = path->dentry->d_inode;
 546         zfsvfs_t *zfsvfs = ITOZSB(ip);
 547         znode_t *dzp;
 548         int error;
 549
 550         ZPL_ENTER(zfsvfs);
 551
 552         if (zfsvfs->z_shares_dir == 0) {
 553 #ifdef HAVE_USERNS_IOPS_GETATTR
 554 #ifdef HAVE_GENERIC_FILLATTR_USERNS
 555                 generic_fillattr(user_ns, path->dentry->d_inode, stat);
 556 #else
 557                 (void) user_ns;
 558 #endif
 559 #else
 560                 generic_fillattr(path->dentry->d_inode, stat);
 561 #endif
 562                 stat->nlink = stat->size = 2;
 563                 stat->atime = current_time(ip);
 564                 ZPL_EXIT(zfsvfs);
 565                 return (0);
 566         }
 567
 568         error = -zfs_zget(zfsvfs, zfsvfs->z_shares_dir, &dzp);
 569         if (error == 0) {
 570 #ifdef HAVE_USERNS_IOPS_GETATTR
 571 #ifdef HAVE_GENERIC_FILLATTR_USERNS
 572                 error = -zfs_getattr_fast(user_ns, ZTOI(dzp), stat);
 573 #else
 574                 (void) user_ns;
 575 #endif
 576 #else
 577                 error = -zfs_getattr_fast(kcred->user_ns, ZTOI(dzp), stat);
 578 #endif
 579                 iput(ZTOI(dzp));
 580         }
 581
 582         ZPL_EXIT(zfsvfs);
 583         ASSERT3S(error, <=, 0);
 584
 585         return (error);
 586 }
 587 ZPL_GETATTR_WRAPPER(zpl_shares_getattr);
 588
 589 /*
 590  * The '.zfs/shares' directory file operations.
 591  */
 592 const struct file_operations zpl_fops_shares = {
 593         .open           = zpl_common_open,
 594         .llseek         = generic_file_llseek,
 595         .read           = generic_read_dir,
 596 #ifdef HAVE_VFS_ITERATE_SHARED
 597         .iterate_shared = zpl_shares_iterate,
 598 #elif defined(HAVE_VFS_ITERATE)
 599         .iterate        = zpl_shares_iterate,
 600 #else
 601         .readdir        = zpl_shares_readdir,
 602 #endif
 603
 604 };
 605
 606 /*
 607  * The '.zfs/shares' directory inode operations.
 608  */
 609 const struct inode_operations zpl_ops_shares = {
 610         .lookup         = zpl_shares_lookup,
 611         .getattr        = zpl_shares_getattr,
 612 };