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