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.
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.
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]
22 * Copyright (c) 2011, Lawrence Livermore National Security, LLC.
23 * Copyright (c) 2015 by Chunwei Chen. All rights reserved.
28 #include <linux/compat.h>
30 #include <sys/dmu_objset.h>
31 #include <sys/zfs_vfsops.h>
32 #include <sys/zfs_vnops.h>
33 #include <sys/zfs_znode.h>
38 zpl_open(struct inode *ip, struct file *filp)
42 fstrans_cookie_t cookie;
44 error = generic_file_open(ip, filp);
49 cookie = spl_fstrans_mark();
50 error = -zfs_open(ip, filp->f_mode, filp->f_flags, cr);
51 spl_fstrans_unmark(cookie);
53 ASSERT3S(error, <=, 0);
59 zpl_release(struct inode *ip, struct file *filp)
63 fstrans_cookie_t cookie;
65 cookie = spl_fstrans_mark();
66 if (ITOZ(ip)->z_atime_dirty)
67 zfs_mark_inode_dirty(ip);
70 error = -zfs_close(ip, filp->f_flags, cr);
71 spl_fstrans_unmark(cookie);
73 ASSERT3S(error, <=, 0);
79 zpl_iterate(struct file *filp, struct dir_context *ctx)
83 fstrans_cookie_t cookie;
86 cookie = spl_fstrans_mark();
87 error = -zfs_readdir(file_inode(filp), ctx, cr);
88 spl_fstrans_unmark(cookie);
90 ASSERT3S(error, <=, 0);
95 #if !defined(HAVE_VFS_ITERATE) && !defined(HAVE_VFS_ITERATE_SHARED)
97 zpl_readdir(struct file *filp, void *dirent, filldir_t filldir)
99 struct dir_context ctx = DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
102 error = zpl_iterate(filp, &ctx);
103 filp->f_pos = ctx.pos;
107 #endif /* HAVE_VFS_ITERATE */
109 #if defined(HAVE_FSYNC_WITH_DENTRY)
111 * Linux 2.6.x - 2.6.34 API,
112 * Through 2.6.34 the nfsd kernel server would pass a NULL 'file struct *'
113 * to the fops->fsync() hook. For this reason, we must be careful not to
114 * use filp unconditionally.
117 zpl_fsync(struct file *filp, struct dentry *dentry, int datasync)
121 fstrans_cookie_t cookie;
124 cookie = spl_fstrans_mark();
125 error = -zfs_fsync(dentry->d_inode, datasync, cr);
126 spl_fstrans_unmark(cookie);
128 ASSERT3S(error, <=, 0);
133 #ifdef HAVE_FILE_AIO_FSYNC
135 zpl_aio_fsync(struct kiocb *kiocb, int datasync)
137 struct file *filp = kiocb->ki_filp;
138 return (zpl_fsync(filp, file_dentry(filp), datasync));
142 #elif defined(HAVE_FSYNC_WITHOUT_DENTRY)
144 * Linux 2.6.35 - 3.0 API,
145 * As of 2.6.35 the dentry argument to the fops->fsync() hook was deemed
146 * redundant. The dentry is still accessible via filp->f_path.dentry,
147 * and we are guaranteed that filp will never be NULL.
150 zpl_fsync(struct file *filp, int datasync)
152 struct inode *inode = filp->f_mapping->host;
155 fstrans_cookie_t cookie;
158 cookie = spl_fstrans_mark();
159 error = -zfs_fsync(inode, datasync, cr);
160 spl_fstrans_unmark(cookie);
162 ASSERT3S(error, <=, 0);
167 #ifdef HAVE_FILE_AIO_FSYNC
169 zpl_aio_fsync(struct kiocb *kiocb, int datasync)
171 return (zpl_fsync(kiocb->ki_filp, datasync));
175 #elif defined(HAVE_FSYNC_RANGE)
177 * Linux 3.1 - 3.x API,
178 * As of 3.1 the responsibility to call filemap_write_and_wait_range() has
179 * been pushed down in to the .fsync() vfs hook. Additionally, the i_mutex
180 * lock is no longer held by the caller, for zfs we don't require the lock
181 * to be held so we don't acquire it.
184 zpl_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
186 struct inode *inode = filp->f_mapping->host;
189 fstrans_cookie_t cookie;
191 error = filemap_write_and_wait_range(inode->i_mapping, start, end);
196 cookie = spl_fstrans_mark();
197 error = -zfs_fsync(inode, datasync, cr);
198 spl_fstrans_unmark(cookie);
200 ASSERT3S(error, <=, 0);
205 #ifdef HAVE_FILE_AIO_FSYNC
207 zpl_aio_fsync(struct kiocb *kiocb, int datasync)
209 return (zpl_fsync(kiocb->ki_filp, kiocb->ki_pos, -1, datasync));
214 #error "Unsupported fops->fsync() implementation"
218 zpl_read_common_iovec(struct inode *ip, const struct iovec *iovp, size_t count,
219 unsigned long nr_segs, loff_t *ppos, uio_seg_t segment, int flags,
220 cred_t *cr, size_t skip)
225 fstrans_cookie_t cookie;
229 uio.uio_resid = count;
230 uio.uio_iovcnt = nr_segs;
231 uio.uio_loffset = *ppos;
232 uio.uio_limit = MAXOFFSET_T;
233 uio.uio_segflg = segment;
235 cookie = spl_fstrans_mark();
236 error = -zfs_read(ip, &uio, flags, cr);
237 spl_fstrans_unmark(cookie);
241 read = count - uio.uio_resid;
243 task_io_account_read(read);
249 zpl_read_common(struct inode *ip, const char *buf, size_t len, loff_t *ppos,
250 uio_seg_t segment, int flags, cred_t *cr)
254 iov.iov_base = (void *)buf;
257 return (zpl_read_common_iovec(ip, &iov, len, 1, ppos, segment,
262 zpl_iter_read_common(struct kiocb *kiocb, const struct iovec *iovp,
263 unsigned long nr_segs, size_t count, uio_seg_t seg, size_t skip)
266 struct file *filp = kiocb->ki_filp;
270 read = zpl_read_common_iovec(filp->f_mapping->host, iovp, count,
271 nr_segs, &kiocb->ki_pos, seg, filp->f_flags, cr, skip);
278 #if defined(HAVE_VFS_RW_ITERATE)
280 zpl_iter_read(struct kiocb *kiocb, struct iov_iter *to)
283 uio_seg_t seg = UIO_USERSPACE;
284 if (to->type & ITER_KVEC)
286 if (to->type & ITER_BVEC)
288 ret = zpl_iter_read_common(kiocb, to->iov, to->nr_segs,
289 iov_iter_count(to), seg, to->iov_offset);
291 iov_iter_advance(to, ret);
296 zpl_aio_read(struct kiocb *kiocb, const struct iovec *iovp,
297 unsigned long nr_segs, loff_t pos)
302 ret = generic_segment_checks(iovp, &nr_segs, &count, VERIFY_WRITE);
306 return (zpl_iter_read_common(kiocb, iovp, nr_segs, count,
309 #endif /* HAVE_VFS_RW_ITERATE */
312 zpl_write_common_iovec(struct inode *ip, const struct iovec *iovp, size_t count,
313 unsigned long nr_segs, loff_t *ppos, uio_seg_t segment, int flags,
314 cred_t *cr, size_t skip)
319 fstrans_cookie_t cookie;
321 if (flags & O_APPEND)
322 *ppos = i_size_read(ip);
326 uio.uio_resid = count;
327 uio.uio_iovcnt = nr_segs;
328 uio.uio_loffset = *ppos;
329 uio.uio_limit = MAXOFFSET_T;
330 uio.uio_segflg = segment;
332 cookie = spl_fstrans_mark();
333 error = -zfs_write(ip, &uio, flags, cr);
334 spl_fstrans_unmark(cookie);
338 wrote = count - uio.uio_resid;
340 task_io_account_write(wrote);
346 zpl_write_common(struct inode *ip, const char *buf, size_t len, loff_t *ppos,
347 uio_seg_t segment, int flags, cred_t *cr)
351 iov.iov_base = (void *)buf;
354 return (zpl_write_common_iovec(ip, &iov, len, 1, ppos, segment,
359 zpl_iter_write_common(struct kiocb *kiocb, const struct iovec *iovp,
360 unsigned long nr_segs, size_t count, uio_seg_t seg, size_t skip)
363 struct file *filp = kiocb->ki_filp;
367 wrote = zpl_write_common_iovec(filp->f_mapping->host, iovp, count,
368 nr_segs, &kiocb->ki_pos, seg, filp->f_flags, cr, skip);
374 #if defined(HAVE_VFS_RW_ITERATE)
376 zpl_iter_write(struct kiocb *kiocb, struct iov_iter *from)
380 uio_seg_t seg = UIO_USERSPACE;
382 #ifndef HAVE_GENERIC_WRITE_CHECKS_KIOCB
383 struct file *file = kiocb->ki_filp;
384 struct address_space *mapping = file->f_mapping;
385 struct inode *ip = mapping->host;
386 int isblk = S_ISBLK(ip->i_mode);
388 count = iov_iter_count(from);
389 ret = generic_write_checks(file, &kiocb->ki_pos, &count, isblk);
394 * XXX - ideally this check should be in the same lock region with
395 * write operations, so that there's no TOCTTOU race when doing
396 * append and someone else grow the file.
398 ret = generic_write_checks(kiocb, from);
404 if (from->type & ITER_KVEC)
406 if (from->type & ITER_BVEC)
409 ret = zpl_iter_write_common(kiocb, from->iov, from->nr_segs,
410 count, seg, from->iov_offset);
412 iov_iter_advance(from, ret);
418 zpl_aio_write(struct kiocb *kiocb, const struct iovec *iovp,
419 unsigned long nr_segs, loff_t pos)
421 struct file *file = kiocb->ki_filp;
422 struct address_space *mapping = file->f_mapping;
423 struct inode *ip = mapping->host;
424 int isblk = S_ISBLK(ip->i_mode);
428 ret = generic_segment_checks(iovp, &nr_segs, &count, VERIFY_READ);
432 ret = generic_write_checks(file, &pos, &count, isblk);
436 return (zpl_iter_write_common(kiocb, iovp, nr_segs, count,
439 #endif /* HAVE_VFS_RW_ITERATE */
442 zpl_llseek(struct file *filp, loff_t offset, int whence)
444 #if defined(SEEK_HOLE) && defined(SEEK_DATA)
445 fstrans_cookie_t cookie;
447 if (whence == SEEK_DATA || whence == SEEK_HOLE) {
448 struct inode *ip = filp->f_mapping->host;
449 loff_t maxbytes = ip->i_sb->s_maxbytes;
452 spl_inode_lock_shared(ip);
453 cookie = spl_fstrans_mark();
454 error = -zfs_holey(ip, whence, &offset);
455 spl_fstrans_unmark(cookie);
457 error = lseek_execute(filp, ip, offset, maxbytes);
458 spl_inode_unlock_shared(ip);
462 #endif /* SEEK_HOLE && SEEK_DATA */
464 return (generic_file_llseek(filp, offset, whence));
468 * It's worth taking a moment to describe how mmap is implemented
469 * for zfs because it differs considerably from other Linux filesystems.
470 * However, this issue is handled the same way under OpenSolaris.
472 * The issue is that by design zfs bypasses the Linux page cache and
473 * leaves all caching up to the ARC. This has been shown to work
474 * well for the common read(2)/write(2) case. However, mmap(2)
475 * is problem because it relies on being tightly integrated with the
476 * page cache. To handle this we cache mmap'ed files twice, once in
477 * the ARC and a second time in the page cache. The code is careful
478 * to keep both copies synchronized.
480 * When a file with an mmap'ed region is written to using write(2)
481 * both the data in the ARC and existing pages in the page cache
482 * are updated. For a read(2) data will be read first from the page
483 * cache then the ARC if needed. Neither a write(2) or read(2) will
484 * will ever result in new pages being added to the page cache.
486 * New pages are added to the page cache only via .readpage() which
487 * is called when the vfs needs to read a page off disk to back the
488 * virtual memory region. These pages may be modified without
489 * notifying the ARC and will be written out periodically via
490 * .writepage(). This will occur due to either a sync or the usual
491 * page aging behavior. Note because a read(2) of a mmap'ed file
492 * will always check the page cache first even when the ARC is out
493 * of date correct data will still be returned.
495 * While this implementation ensures correct behavior it does have
496 * have some drawbacks. The most obvious of which is that it
497 * increases the required memory footprint when access mmap'ed
498 * files. It also adds additional complexity to the code keeping
499 * both caches synchronized.
501 * Longer term it may be possible to cleanly resolve this wart by
502 * mapping page cache pages directly on to the ARC buffers. The
503 * Linux address space operations are flexible enough to allow
504 * selection of which pages back a particular index. The trick
505 * would be working out the details of which subsystem is in
506 * charge, the ARC, the page cache, or both. It may also prove
507 * helpful to move the ARC buffers to a scatter-gather lists
508 * rather than a vmalloc'ed region.
511 zpl_mmap(struct file *filp, struct vm_area_struct *vma)
513 struct inode *ip = filp->f_mapping->host;
514 znode_t *zp = ITOZ(ip);
516 fstrans_cookie_t cookie;
518 cookie = spl_fstrans_mark();
519 error = -zfs_map(ip, vma->vm_pgoff, (caddr_t *)vma->vm_start,
520 (size_t)(vma->vm_end - vma->vm_start), vma->vm_flags);
521 spl_fstrans_unmark(cookie);
525 error = generic_file_mmap(filp, vma);
529 mutex_enter(&zp->z_lock);
531 mutex_exit(&zp->z_lock);
537 * Populate a page with data for the Linux page cache. This function is
538 * only used to support mmap(2). There will be an identical copy of the
539 * data in the ARC which is kept up to date via .write() and .writepage().
541 * Current this function relies on zpl_read_common() and the O_DIRECT
542 * flag to read in a page. This works but the more correct way is to
543 * update zfs_fillpage() to be Linux friendly and use that interface.
546 zpl_readpage(struct file *filp, struct page *pp)
551 fstrans_cookie_t cookie;
553 ASSERT(PageLocked(pp));
554 ip = pp->mapping->host;
557 cookie = spl_fstrans_mark();
558 error = -zfs_getpage(ip, pl, 1);
559 spl_fstrans_unmark(cookie);
563 ClearPageUptodate(pp);
567 flush_dcache_page(pp);
575 * Populate a set of pages with data for the Linux page cache. This
576 * function will only be called for read ahead and never for demand
577 * paging. For simplicity, the code relies on read_cache_pages() to
578 * correctly lock each page for IO and call zpl_readpage().
581 zpl_readpages(struct file *filp, struct address_space *mapping,
582 struct list_head *pages, unsigned nr_pages)
584 return (read_cache_pages(mapping, pages,
585 (filler_t *)zpl_readpage, filp));
589 zpl_putpage(struct page *pp, struct writeback_control *wbc, void *data)
591 struct address_space *mapping = data;
592 fstrans_cookie_t cookie;
594 ASSERT(PageLocked(pp));
595 ASSERT(!PageWriteback(pp));
597 cookie = spl_fstrans_mark();
598 (void) zfs_putpage(mapping->host, pp, wbc);
599 spl_fstrans_unmark(cookie);
605 zpl_writepages(struct address_space *mapping, struct writeback_control *wbc)
607 znode_t *zp = ITOZ(mapping->host);
608 zfsvfs_t *zfsvfs = ITOZSB(mapping->host);
609 enum writeback_sync_modes sync_mode;
613 if (zfsvfs->z_os->os_sync == ZFS_SYNC_ALWAYS)
614 wbc->sync_mode = WB_SYNC_ALL;
616 sync_mode = wbc->sync_mode;
619 * We don't want to run write_cache_pages() in SYNC mode here, because
620 * that would make putpage() wait for a single page to be committed to
621 * disk every single time, resulting in atrocious performance. Instead
622 * we run it once in non-SYNC mode so that the ZIL gets all the data,
623 * and then we commit it all in one go.
625 wbc->sync_mode = WB_SYNC_NONE;
626 result = write_cache_pages(mapping, wbc, zpl_putpage, mapping);
627 if (sync_mode != wbc->sync_mode) {
630 if (zfsvfs->z_log != NULL)
631 zil_commit(zfsvfs->z_log, zp->z_id);
635 * We need to call write_cache_pages() again (we can't just
636 * return after the commit) because the previous call in
637 * non-SYNC mode does not guarantee that we got all the dirty
638 * pages (see the implementation of write_cache_pages() for
639 * details). That being said, this is a no-op in most cases.
641 wbc->sync_mode = sync_mode;
642 result = write_cache_pages(mapping, wbc, zpl_putpage, mapping);
648 * Write out dirty pages to the ARC, this function is only required to
649 * support mmap(2). Mapped pages may be dirtied by memory operations
650 * which never call .write(). These dirty pages are kept in sync with
651 * the ARC buffers via this hook.
654 zpl_writepage(struct page *pp, struct writeback_control *wbc)
656 if (ITOZSB(pp->mapping->host)->z_os->os_sync == ZFS_SYNC_ALWAYS)
657 wbc->sync_mode = WB_SYNC_ALL;
659 return (zpl_putpage(pp, wbc, pp->mapping));
663 * The only flag combination which matches the behavior of zfs_space()
664 * is FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE. The FALLOC_FL_PUNCH_HOLE
665 * flag was introduced in the 2.6.38 kernel.
667 #if defined(HAVE_FILE_FALLOCATE) || defined(HAVE_INODE_FALLOCATE)
669 zpl_fallocate_common(struct inode *ip, int mode, loff_t offset, loff_t len)
671 int error = -EOPNOTSUPP;
673 #if defined(FALLOC_FL_PUNCH_HOLE) && defined(FALLOC_FL_KEEP_SIZE)
677 fstrans_cookie_t cookie;
679 if (mode != (FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
682 if (offset < 0 || len <= 0)
686 olen = i_size_read(ip);
689 spl_inode_unlock(ip);
692 if (offset + len > olen)
701 cookie = spl_fstrans_mark();
702 error = -zfs_space(ip, F_FREESP, &bf, FWRITE, offset, cr);
703 spl_fstrans_unmark(cookie);
704 spl_inode_unlock(ip);
707 #endif /* defined(FALLOC_FL_PUNCH_HOLE) && defined(FALLOC_FL_KEEP_SIZE) */
709 ASSERT3S(error, <=, 0);
712 #endif /* defined(HAVE_FILE_FALLOCATE) || defined(HAVE_INODE_FALLOCATE) */
714 #ifdef HAVE_FILE_FALLOCATE
716 zpl_fallocate(struct file *filp, int mode, loff_t offset, loff_t len)
718 return zpl_fallocate_common(file_inode(filp),
721 #endif /* HAVE_FILE_FALLOCATE */
724 * Map zfs file z_pflags (xvattr_t) to linux file attributes. Only file
725 * attributes common to both Linux and Solaris are mapped.
728 zpl_ioctl_getflags(struct file *filp, void __user *arg)
730 struct inode *ip = file_inode(filp);
731 unsigned int ioctl_flags = 0;
732 uint64_t zfs_flags = ITOZ(ip)->z_pflags;
735 if (zfs_flags & ZFS_IMMUTABLE)
736 ioctl_flags |= FS_IMMUTABLE_FL;
738 if (zfs_flags & ZFS_APPENDONLY)
739 ioctl_flags |= FS_APPEND_FL;
741 if (zfs_flags & ZFS_NODUMP)
742 ioctl_flags |= FS_NODUMP_FL;
744 ioctl_flags &= FS_FL_USER_VISIBLE;
746 error = copy_to_user(arg, &ioctl_flags, sizeof (ioctl_flags));
752 * fchange() is a helper macro to detect if we have been asked to change a
753 * flag. This is ugly, but the requirement that we do this is a consequence of
754 * how the Linux file attribute interface was designed. Another consequence is
755 * that concurrent modification of files suffers from a TOCTOU race. Neither
756 * are things we can fix without modifying the kernel-userland interface, which
757 * is outside of our jurisdiction.
760 #define fchange(f0, f1, b0, b1) (!((f0) & (b0)) != !((f1) & (b1)))
763 zpl_ioctl_setflags(struct file *filp, void __user *arg)
765 struct inode *ip = file_inode(filp);
766 uint64_t zfs_flags = ITOZ(ip)->z_pflags;
767 unsigned int ioctl_flags;
772 fstrans_cookie_t cookie;
774 if (copy_from_user(&ioctl_flags, arg, sizeof (ioctl_flags)))
777 if ((ioctl_flags & ~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NODUMP_FL)))
778 return (-EOPNOTSUPP);
780 if ((ioctl_flags & ~(FS_FL_USER_MODIFIABLE)))
783 if ((fchange(ioctl_flags, zfs_flags, FS_IMMUTABLE_FL, ZFS_IMMUTABLE) ||
784 fchange(ioctl_flags, zfs_flags, FS_APPEND_FL, ZFS_APPENDONLY)) &&
785 !capable(CAP_LINUX_IMMUTABLE))
788 if (!zpl_inode_owner_or_capable(ip))
792 xoap = xva_getxoptattr(&xva);
794 XVA_SET_REQ(&xva, XAT_IMMUTABLE);
795 if (ioctl_flags & FS_IMMUTABLE_FL)
796 xoap->xoa_immutable = B_TRUE;
798 XVA_SET_REQ(&xva, XAT_APPENDONLY);
799 if (ioctl_flags & FS_APPEND_FL)
800 xoap->xoa_appendonly = B_TRUE;
802 XVA_SET_REQ(&xva, XAT_NODUMP);
803 if (ioctl_flags & FS_NODUMP_FL)
804 xoap->xoa_nodump = B_TRUE;
807 cookie = spl_fstrans_mark();
808 error = -zfs_setattr(ip, (vattr_t *)&xva, 0, cr);
809 spl_fstrans_unmark(cookie);
816 zpl_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
819 case FS_IOC_GETFLAGS:
820 return (zpl_ioctl_getflags(filp, (void *)arg));
821 case FS_IOC_SETFLAGS:
822 return (zpl_ioctl_setflags(filp, (void *)arg));
830 zpl_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
833 case FS_IOC32_GETFLAGS:
834 cmd = FS_IOC_GETFLAGS;
836 case FS_IOC32_SETFLAGS:
837 cmd = FS_IOC_SETFLAGS;
842 return (zpl_ioctl(filp, cmd, (unsigned long)compat_ptr(arg)));
844 #endif /* CONFIG_COMPAT */
847 const struct address_space_operations zpl_address_space_operations = {
848 .readpages = zpl_readpages,
849 .readpage = zpl_readpage,
850 .writepage = zpl_writepage,
851 .writepages = zpl_writepages,
854 const struct file_operations zpl_file_operations = {
856 .release = zpl_release,
857 .llseek = zpl_llseek,
858 #ifdef HAVE_VFS_RW_ITERATE
859 #ifdef HAVE_NEW_SYNC_READ
860 .read = new_sync_read,
861 .write = new_sync_write,
863 .read_iter = zpl_iter_read,
864 .write_iter = zpl_iter_write,
866 .read = do_sync_read,
867 .write = do_sync_write,
868 .aio_read = zpl_aio_read,
869 .aio_write = zpl_aio_write,
873 #ifdef HAVE_FILE_AIO_FSYNC
874 .aio_fsync = zpl_aio_fsync,
876 #ifdef HAVE_FILE_FALLOCATE
877 .fallocate = zpl_fallocate,
878 #endif /* HAVE_FILE_FALLOCATE */
879 .unlocked_ioctl = zpl_ioctl,
881 .compat_ioctl = zpl_compat_ioctl,
885 const struct file_operations zpl_dir_file_operations = {
886 .llseek = generic_file_llseek,
887 .read = generic_read_dir,
888 #ifdef HAVE_VFS_ITERATE_SHARED
889 .iterate_shared = zpl_iterate,
890 #elif defined(HAVE_VFS_ITERATE)
891 .iterate = zpl_iterate,
893 .readdir = zpl_readdir,
896 .unlocked_ioctl = zpl_ioctl,
898 .compat_ioctl = zpl_compat_ioctl,