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.
27 #include <sys/zfs_ctldir.h>
28 #include <sys/zfs_vfsops.h>
29 #include <sys/zfs_vnops.h>
30 #include <sys/zfs_znode.h>
31 #include <sys/dmu_objset.h>
37 static struct dentry *
38 #ifdef HAVE_LOOKUP_NAMEIDATA
39 zpl_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
41 zpl_lookup(struct inode *dir, struct dentry *dentry, unsigned int flags)
47 fstrans_cookie_t cookie;
48 pathname_t *ppn = NULL;
51 zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
53 if (dlen(dentry) >= ZAP_MAXNAMELEN)
54 return (ERR_PTR(-ENAMETOOLONG));
57 cookie = spl_fstrans_mark();
59 /* If we are a case insensitive fs, we need the real name */
60 if (zfsvfs->z_case == ZFS_CASE_INSENSITIVE) {
61 zfs_flags = FIGNORECASE;
66 error = -zfs_lookup(dir, dname(dentry), &ip, zfs_flags, cr, NULL, ppn);
67 spl_fstrans_unmark(cookie);
68 ASSERT3S(error, <=, 0);
71 spin_lock(&dentry->d_lock);
72 dentry->d_time = jiffies;
74 d_set_d_op(dentry, &zpl_dentry_operations);
75 #endif /* HAVE_S_D_OP */
76 spin_unlock(&dentry->d_lock);
80 * If we have a case sensitive fs, we do not want to
81 * insert negative entries, so return NULL for ENOENT.
82 * Fall through if the error is not ENOENT. Also free memory.
91 return (d_splice_alias(NULL, dentry));
93 return (ERR_PTR(error));
97 * If we are case insensitive, call the correct function
98 * to install the name.
101 struct dentry *new_dentry;
104 if (strcmp(dname(dentry), pn.pn_buf) == 0) {
105 new_dentry = d_splice_alias(ip, dentry);
107 ci_name.name = pn.pn_buf;
108 ci_name.len = strlen(pn.pn_buf);
109 new_dentry = d_add_ci(dentry, ip, &ci_name);
114 return (d_splice_alias(ip, dentry));
119 zpl_vap_init(vattr_t *vap, struct inode *dir, zpl_umode_t mode, cred_t *cr)
121 vap->va_mask = ATTR_MODE;
123 vap->va_uid = crgetfsuid(cr);
125 if (dir && dir->i_mode & S_ISGID) {
126 vap->va_gid = KGID_TO_SGID(dir->i_gid);
128 vap->va_mode |= S_ISGID;
130 vap->va_gid = crgetfsgid(cr);
135 #ifdef HAVE_CREATE_NAMEIDATA
136 zpl_create(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
137 struct nameidata *nd)
139 zpl_create(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
147 fstrans_cookie_t cookie;
150 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
151 zpl_vap_init(vap, dir, mode, cr);
153 cookie = spl_fstrans_mark();
154 error = -zfs_create(dir, dname(dentry), vap, 0, mode, &ip, cr, 0, NULL);
156 d_instantiate(dentry, ip);
158 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
160 error = zpl_init_acl(ip, dir);
163 (void) zfs_remove(dir, dname(dentry), cr, 0);
166 spl_fstrans_unmark(cookie);
167 kmem_free(vap, sizeof (vattr_t));
169 ASSERT3S(error, <=, 0);
175 zpl_mknod(struct inode *dir, struct dentry *dentry, zpl_umode_t mode,
182 fstrans_cookie_t cookie;
185 * We currently expect Linux to supply rdev=0 for all sockets
186 * and fifos, but we want to know if this behavior ever changes.
188 if (S_ISSOCK(mode) || S_ISFIFO(mode))
192 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
193 zpl_vap_init(vap, dir, mode, cr);
196 cookie = spl_fstrans_mark();
197 error = -zfs_create(dir, dname(dentry), vap, 0, mode, &ip, cr, 0, NULL);
199 d_instantiate(dentry, ip);
201 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
203 error = zpl_init_acl(ip, dir);
206 (void) zfs_remove(dir, dname(dentry), cr, 0);
209 spl_fstrans_unmark(cookie);
210 kmem_free(vap, sizeof (vattr_t));
212 ASSERT3S(error, <=, 0);
219 zpl_tmpfile(struct inode *dir, struct dentry *dentry, zpl_umode_t mode)
225 fstrans_cookie_t cookie;
228 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
229 zpl_vap_init(vap, dir, mode, cr);
231 cookie = spl_fstrans_mark();
232 error = -zfs_tmpfile(dir, vap, 0, mode, &ip, cr, 0, NULL);
234 /* d_tmpfile will do drop_nlink, so we should set it first */
236 d_tmpfile(dentry, ip);
238 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
240 error = zpl_init_acl(ip, dir);
242 * don't need to handle error here, file is already in
247 spl_fstrans_unmark(cookie);
248 kmem_free(vap, sizeof (vattr_t));
250 ASSERT3S(error, <=, 0);
257 zpl_unlink(struct inode *dir, struct dentry *dentry)
261 fstrans_cookie_t cookie;
262 zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
265 cookie = spl_fstrans_mark();
266 error = -zfs_remove(dir, dname(dentry), cr, 0);
269 * For a CI FS we must invalidate the dentry to prevent the
270 * creation of negative entries.
272 if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
273 d_invalidate(dentry);
275 spl_fstrans_unmark(cookie);
277 ASSERT3S(error, <=, 0);
283 zpl_mkdir(struct inode *dir, struct dentry *dentry, zpl_umode_t mode)
289 fstrans_cookie_t cookie;
292 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
293 zpl_vap_init(vap, dir, mode | S_IFDIR, cr);
295 cookie = spl_fstrans_mark();
296 error = -zfs_mkdir(dir, dname(dentry), vap, &ip, cr, 0, NULL);
298 d_instantiate(dentry, ip);
300 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
302 error = zpl_init_acl(ip, dir);
305 (void) zfs_rmdir(dir, dname(dentry), NULL, cr, 0);
308 spl_fstrans_unmark(cookie);
309 kmem_free(vap, sizeof (vattr_t));
311 ASSERT3S(error, <=, 0);
317 zpl_rmdir(struct inode *dir, struct dentry *dentry)
321 fstrans_cookie_t cookie;
322 zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
325 cookie = spl_fstrans_mark();
326 error = -zfs_rmdir(dir, dname(dentry), NULL, cr, 0);
329 * For a CI FS we must invalidate the dentry to prevent the
330 * creation of negative entries.
332 if (error == 0 && zfsvfs->z_case == ZFS_CASE_INSENSITIVE)
333 d_invalidate(dentry);
335 spl_fstrans_unmark(cookie);
337 ASSERT3S(error, <=, 0);
343 zpl_getattr_impl(const struct path *path, struct kstat *stat, u32 request_mask,
344 unsigned int query_flags)
347 fstrans_cookie_t cookie;
349 cookie = spl_fstrans_mark();
352 * XXX request_mask and query_flags currently ignored.
355 error = -zfs_getattr_fast(path->dentry->d_inode, stat);
356 spl_fstrans_unmark(cookie);
357 ASSERT3S(error, <=, 0);
361 ZPL_GETATTR_WRAPPER(zpl_getattr);
364 zpl_setattr(struct dentry *dentry, struct iattr *ia)
366 struct inode *ip = dentry->d_inode;
370 fstrans_cookie_t cookie;
372 error = setattr_prepare(dentry, ia);
377 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
378 vap->va_mask = ia->ia_valid & ATTR_IATTR_MASK;
379 vap->va_mode = ia->ia_mode;
380 vap->va_uid = KUID_TO_SUID(ia->ia_uid);
381 vap->va_gid = KGID_TO_SGID(ia->ia_gid);
382 vap->va_size = ia->ia_size;
383 vap->va_atime = ia->ia_atime;
384 vap->va_mtime = ia->ia_mtime;
385 vap->va_ctime = ia->ia_ctime;
387 if (vap->va_mask & ATTR_ATIME)
388 ip->i_atime = timespec_trunc(ia->ia_atime,
389 ip->i_sb->s_time_gran);
391 cookie = spl_fstrans_mark();
392 error = -zfs_setattr(ip, vap, 0, cr);
393 if (!error && (ia->ia_valid & ATTR_MODE))
394 error = zpl_chmod_acl(ip);
396 spl_fstrans_unmark(cookie);
397 kmem_free(vap, sizeof (vattr_t));
399 ASSERT3S(error, <=, 0);
405 zpl_rename2(struct inode *sdip, struct dentry *sdentry,
406 struct inode *tdip, struct dentry *tdentry, unsigned int flags)
410 fstrans_cookie_t cookie;
412 /* We don't have renameat2(2) support */
417 cookie = spl_fstrans_mark();
418 error = -zfs_rename(sdip, dname(sdentry), tdip, dname(tdentry), cr, 0);
419 spl_fstrans_unmark(cookie);
421 ASSERT3S(error, <=, 0);
426 #ifndef HAVE_RENAME_WANTS_FLAGS
428 zpl_rename(struct inode *sdip, struct dentry *sdentry,
429 struct inode *tdip, struct dentry *tdentry)
431 return (zpl_rename2(sdip, sdentry, tdip, tdentry, 0));
436 zpl_symlink(struct inode *dir, struct dentry *dentry, const char *name)
442 fstrans_cookie_t cookie;
445 vap = kmem_zalloc(sizeof (vattr_t), KM_SLEEP);
446 zpl_vap_init(vap, dir, S_IFLNK | S_IRWXUGO, cr);
448 cookie = spl_fstrans_mark();
449 error = -zfs_symlink(dir, dname(dentry), vap, (char *)name, &ip, cr, 0);
451 d_instantiate(dentry, ip);
453 error = zpl_xattr_security_init(ip, dir, &dentry->d_name);
455 (void) zfs_remove(dir, dname(dentry), cr, 0);
458 spl_fstrans_unmark(cookie);
459 kmem_free(vap, sizeof (vattr_t));
461 ASSERT3S(error, <=, 0);
466 #if defined(HAVE_PUT_LINK_COOKIE)
468 zpl_put_link(struct inode *unused, void *cookie)
470 kmem_free(cookie, MAXPATHLEN);
472 #elif defined(HAVE_PUT_LINK_NAMEIDATA)
474 zpl_put_link(struct dentry *dentry, struct nameidata *nd, void *ptr)
476 const char *link = nd_get_link(nd);
479 kmem_free(link, MAXPATHLEN);
481 #elif defined(HAVE_PUT_LINK_DELAYED)
483 zpl_put_link(void *ptr)
485 kmem_free(ptr, MAXPATHLEN);
490 zpl_get_link_common(struct dentry *dentry, struct inode *ip, char **link)
492 fstrans_cookie_t cookie;
500 iov.iov_len = MAXPATHLEN;
501 iov.iov_base = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
506 uio.uio_resid = (MAXPATHLEN - 1);
507 uio.uio_segflg = UIO_SYSSPACE;
509 cookie = spl_fstrans_mark();
510 error = -zfs_readlink(ip, &uio, cr);
511 spl_fstrans_unmark(cookie);
515 kmem_free(iov.iov_base, MAXPATHLEN);
517 *link = iov.iov_base;
522 #if defined(HAVE_GET_LINK_DELAYED)
524 zpl_get_link(struct dentry *dentry, struct inode *inode,
525 struct delayed_call *done)
531 return (ERR_PTR(-ECHILD));
533 error = zpl_get_link_common(dentry, inode, &link);
535 return (ERR_PTR(error));
537 set_delayed_call(done, zpl_put_link, link);
541 #elif defined(HAVE_GET_LINK_COOKIE)
543 zpl_get_link(struct dentry *dentry, struct inode *inode, void **cookie)
549 return (ERR_PTR(-ECHILD));
551 error = zpl_get_link_common(dentry, inode, &link);
553 return (ERR_PTR(error));
555 return (*cookie = link);
557 #elif defined(HAVE_FOLLOW_LINK_COOKIE)
559 zpl_follow_link(struct dentry *dentry, void **cookie)
564 error = zpl_get_link_common(dentry, dentry->d_inode, &link);
566 return (ERR_PTR(error));
568 return (*cookie = link);
570 #elif defined(HAVE_FOLLOW_LINK_NAMEIDATA)
572 zpl_follow_link(struct dentry *dentry, struct nameidata *nd)
577 error = zpl_get_link_common(dentry, dentry->d_inode, &link);
579 nd_set_link(nd, ERR_PTR(error));
581 nd_set_link(nd, link);
588 zpl_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
591 struct inode *ip = old_dentry->d_inode;
593 fstrans_cookie_t cookie;
595 if (ip->i_nlink >= ZFS_LINK_MAX)
599 ip->i_ctime = CURRENT_TIME_SEC;
600 igrab(ip); /* Use ihold() if available */
602 cookie = spl_fstrans_mark();
603 error = -zfs_link(dir, ip, dname(dentry), cr, 0);
609 d_instantiate(dentry, ip);
611 spl_fstrans_unmark(cookie);
613 ASSERT3S(error, <=, 0);
618 #ifdef HAVE_INODE_TRUNCATE_RANGE
620 zpl_truncate_range(struct inode *ip, loff_t start, loff_t end)
624 fstrans_cookie_t cookie;
626 ASSERT3S(start, <=, end);
629 * zfs_freesp() will interpret (len == 0) as meaning "truncate until
630 * the end of the file". We don't want that.
640 bf.l_len = end - start;
642 cookie = spl_fstrans_mark();
643 zfs_space(ip, F_FREESP, &bf, FWRITE, start, cr);
644 spl_fstrans_unmark(cookie);
648 #endif /* HAVE_INODE_TRUNCATE_RANGE */
650 #ifdef HAVE_INODE_FALLOCATE
652 zpl_fallocate(struct inode *ip, int mode, loff_t offset, loff_t len)
654 return (zpl_fallocate_common(ip, mode, offset, len));
656 #endif /* HAVE_INODE_FALLOCATE */
659 #ifdef HAVE_D_REVALIDATE_NAMEIDATA
660 zpl_revalidate(struct dentry *dentry, struct nameidata *nd)
662 unsigned int flags = (nd ? nd->flags : 0);
664 zpl_revalidate(struct dentry *dentry, unsigned int flags)
666 #endif /* HAVE_D_REVALIDATE_NAMEIDATA */
668 zfsvfs_t *zfsvfs = dentry->d_sb->s_fs_info;
671 if (flags & LOOKUP_RCU)
675 * Automounted snapshots rely on periodic dentry revalidation
676 * to defer snapshots from being automatically unmounted.
678 if (zfsvfs->z_issnap) {
679 if (time_after(jiffies, zfsvfs->z_snap_defer_time +
680 MAX(zfs_expire_snapshot * HZ / 2, HZ))) {
681 zfsvfs->z_snap_defer_time = jiffies;
682 zfsctl_snapshot_unmount_delay(zfsvfs->z_os->os_spa,
683 dmu_objset_id(zfsvfs->z_os), zfs_expire_snapshot);
688 * After a rollback negative dentries created before the rollback
689 * time must be invalidated. Otherwise they can obscure files which
690 * are only present in the rolled back dataset.
692 if (dentry->d_inode == NULL) {
693 spin_lock(&dentry->d_lock);
694 error = time_before(dentry->d_time, zfsvfs->z_rollback_time);
695 spin_unlock(&dentry->d_lock);
702 * The dentry may reference a stale inode if a mounted file system
703 * was rolled back to a point in time where the object didn't exist.
705 if (dentry->d_inode && ITOZ(dentry->d_inode)->z_is_stale)
711 const struct inode_operations zpl_inode_operations = {
712 .setattr = zpl_setattr,
713 .getattr = zpl_getattr,
714 #ifdef HAVE_GENERIC_SETXATTR
715 .setxattr = generic_setxattr,
716 .getxattr = generic_getxattr,
717 .removexattr = generic_removexattr,
719 .listxattr = zpl_xattr_list,
720 #ifdef HAVE_INODE_TRUNCATE_RANGE
721 .truncate_range = zpl_truncate_range,
722 #endif /* HAVE_INODE_TRUNCATE_RANGE */
723 #ifdef HAVE_INODE_FALLOCATE
724 .fallocate = zpl_fallocate,
725 #endif /* HAVE_INODE_FALLOCATE */
726 #if defined(CONFIG_FS_POSIX_ACL)
727 #if defined(HAVE_SET_ACL)
728 .set_acl = zpl_set_acl,
730 #if defined(HAVE_GET_ACL)
731 .get_acl = zpl_get_acl,
732 #elif defined(HAVE_CHECK_ACL)
733 .check_acl = zpl_check_acl,
734 #elif defined(HAVE_PERMISSION)
735 .permission = zpl_permission,
736 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
737 #endif /* CONFIG_FS_POSIX_ACL */
740 const struct inode_operations zpl_dir_inode_operations = {
741 .create = zpl_create,
742 .lookup = zpl_lookup,
744 .unlink = zpl_unlink,
745 .symlink = zpl_symlink,
749 #ifdef HAVE_RENAME_WANTS_FLAGS
750 .rename = zpl_rename2,
752 .rename = zpl_rename,
755 .tmpfile = zpl_tmpfile,
757 .setattr = zpl_setattr,
758 .getattr = zpl_getattr,
759 #ifdef HAVE_GENERIC_SETXATTR
760 .setxattr = generic_setxattr,
761 .getxattr = generic_getxattr,
762 .removexattr = generic_removexattr,
764 .listxattr = zpl_xattr_list,
765 #if defined(CONFIG_FS_POSIX_ACL)
766 #if defined(HAVE_SET_ACL)
767 .set_acl = zpl_set_acl,
769 #if defined(HAVE_GET_ACL)
770 .get_acl = zpl_get_acl,
771 #elif defined(HAVE_CHECK_ACL)
772 .check_acl = zpl_check_acl,
773 #elif defined(HAVE_PERMISSION)
774 .permission = zpl_permission,
775 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
776 #endif /* CONFIG_FS_POSIX_ACL */
779 const struct inode_operations zpl_symlink_inode_operations = {
780 #ifdef HAVE_GENERIC_READLINK
781 .readlink = generic_readlink,
783 #if defined(HAVE_GET_LINK_DELAYED) || defined(HAVE_GET_LINK_COOKIE)
784 .get_link = zpl_get_link,
785 #elif defined(HAVE_FOLLOW_LINK_COOKIE) || defined(HAVE_FOLLOW_LINK_NAMEIDATA)
786 .follow_link = zpl_follow_link,
788 #if defined(HAVE_PUT_LINK_COOKIE) || defined(HAVE_PUT_LINK_NAMEIDATA)
789 .put_link = zpl_put_link,
791 .setattr = zpl_setattr,
792 .getattr = zpl_getattr,
793 #ifdef HAVE_GENERIC_SETXATTR
794 .setxattr = generic_setxattr,
795 .getxattr = generic_getxattr,
796 .removexattr = generic_removexattr,
798 .listxattr = zpl_xattr_list,
801 const struct inode_operations zpl_special_inode_operations = {
802 .setattr = zpl_setattr,
803 .getattr = zpl_getattr,
804 #ifdef HAVE_GENERIC_SETXATTR
805 .setxattr = generic_setxattr,
806 .getxattr = generic_getxattr,
807 .removexattr = generic_removexattr,
809 .listxattr = zpl_xattr_list,
810 #if defined(CONFIG_FS_POSIX_ACL)
811 #if defined(HAVE_SET_ACL)
812 .set_acl = zpl_set_acl,
814 #if defined(HAVE_GET_ACL)
815 .get_acl = zpl_get_acl,
816 #elif defined(HAVE_CHECK_ACL)
817 .check_acl = zpl_check_acl,
818 #elif defined(HAVE_PERMISSION)
819 .permission = zpl_permission,
820 #endif /* HAVE_GET_ACL | HAVE_CHECK_ACL | HAVE_PERMISSION */
821 #endif /* CONFIG_FS_POSIX_ACL */
824 dentry_operations_t zpl_dentry_operations = {
825 .d_revalidate = zpl_revalidate,