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.
24 * Extended attributes (xattr) on Solaris are implemented as files
25 * which exist in a hidden xattr directory. These extended attributes
26 * can be accessed using the attropen() system call which opens
27 * the extended attribute. It can then be manipulated just like
28 * a standard file descriptor. This has a couple advantages such
29 * as practically no size limit on the file, and the extended
30 * attributes permissions may differ from those of the parent file.
31 * This interface is really quite clever, but it's also completely
32 * different than what is supported on Linux. It also comes with a
33 * steep performance penalty when accessing small xattrs because they
34 * are not stored with the parent file.
36 * Under Linux extended attributes are manipulated by the system
37 * calls getxattr(2), setxattr(2), and listxattr(2). They consider
38 * extended attributes to be name/value pairs where the name is a
39 * NULL terminated string. The name must also include one of the
40 * following namespace prefixes:
42 * user - No restrictions and is available to user applications.
43 * trusted - Restricted to kernel and root (CAP_SYS_ADMIN) use.
44 * system - Used for access control lists (system.nfs4_acl, etc).
45 * security - Used by SELinux to store a files security context.
47 * The value under Linux to limited to 65536 bytes of binary data.
48 * In practice, individual xattrs tend to be much smaller than this
49 * and are typically less than 100 bytes. A good example of this
50 * are the security.selinux xattrs which are less than 100 bytes and
51 * exist for every file when xattr labeling is enabled.
53 * The Linux xattr implemenation has been written to take advantage of
54 * this typical usage. When the dataset property 'xattr=sa' is set,
55 * then xattrs will be preferentially stored as System Attributes (SA).
56 * This allows tiny xattrs (~100 bytes) to be stored with the dnode and
57 * up to 64k of xattrs to be stored in the spill block. If additional
58 * xattr space is required, which is unlikely under Linux, they will
59 * be stored using the traditional directory approach.
61 * This optimization results in roughly a 3x performance improvement
62 * when accessing xattrs because it avoids the need to perform a seek
63 * for every xattr value. When multiple xattrs are stored per-file
64 * the performance improvements are even greater because all of the
65 * xattrs stored in the spill block will be cached.
67 * However, by default SA based xattrs are disabled in the Linux port
68 * to maximize compatibility with other implementations. If you do
69 * enable SA based xattrs then they will not be visible on platforms
70 * which do not support this feature.
72 * NOTE: One additional consequence of the xattr directory implementation
73 * is that when an extended attribute is manipulated an inode is created.
74 * This inode will exist in the Linux inode cache but there will be no
75 * associated entry in the dentry cache which references it. This is
76 * safe but it may result in some confusion. Enabling SA based xattrs
77 * largely avoids the issue except in the overflow case.
80 #include <sys/zfs_vfsops.h>
81 #include <sys/zfs_vnops.h>
82 #include <sys/zfs_znode.h>
87 typedef struct xattr_filldir
{
95 zpl_xattr_filldir(xattr_filldir_t
*xf
, const char *name
, int name_len
)
97 if (!strncmp(name
, XATTR_USER_PREFIX
, XATTR_USER_PREFIX_LEN
))
98 if (!(ITOZSB(xf
->inode
)->z_flags
& ZSB_XATTR
))
101 if (!strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
))
102 if (!capable(CAP_SYS_ADMIN
))
105 /* When xf->buf is NULL only calculate the required size. */
107 if (xf
->offset
+ name_len
+ 1 > xf
->size
)
110 memcpy(xf
->buf
+ xf
->offset
, name
, name_len
);
111 xf
->buf
[xf
->offset
+ name_len
] = '\0';
114 xf
->offset
+= (name_len
+ 1);
120 * Read as many directory entry names as will fit in to the provided buffer,
121 * or when no buffer is provided calculate the required buffer size.
124 zpl_xattr_readdir(struct inode
*dxip
, xattr_filldir_t
*xf
)
130 zap_cursor_init(&zc
, ITOZSB(dxip
)->z_os
, ITOZ(dxip
)->z_id
);
132 while ((error
= -zap_cursor_retrieve(&zc
, &zap
)) == 0) {
134 if (zap
.za_integer_length
!= 8 || zap
.za_num_integers
!= 1) {
139 error
= zpl_xattr_filldir(xf
, zap
.za_name
, strlen(zap
.za_name
));
143 zap_cursor_advance(&zc
);
146 zap_cursor_fini(&zc
);
148 if (error
== -ENOENT
)
155 zpl_xattr_list_dir(xattr_filldir_t
*xf
, cred_t
*cr
)
157 struct inode
*ip
= xf
->inode
;
158 struct inode
*dxip
= NULL
;
161 /* Lookup the xattr directory */
162 error
= -zfs_lookup(ip
, NULL
, &dxip
, LOOKUP_XATTR
, cr
, NULL
, NULL
);
164 if (error
== -ENOENT
)
170 error
= zpl_xattr_readdir(dxip
, xf
);
177 zpl_xattr_list_sa(xattr_filldir_t
*xf
)
179 znode_t
*zp
= ITOZ(xf
->inode
);
180 nvpair_t
*nvp
= NULL
;
183 mutex_enter(&zp
->z_lock
);
184 if (zp
->z_xattr_cached
== NULL
)
185 error
= -zfs_sa_get_xattr(zp
);
186 mutex_exit(&zp
->z_lock
);
191 ASSERT(zp
->z_xattr_cached
);
193 while ((nvp
= nvlist_next_nvpair(zp
->z_xattr_cached
, nvp
)) != NULL
) {
194 ASSERT3U(nvpair_type(nvp
), ==, DATA_TYPE_BYTE_ARRAY
);
196 error
= zpl_xattr_filldir(xf
, nvpair_name(nvp
),
197 strlen(nvpair_name(nvp
)));
206 zpl_xattr_list(struct dentry
*dentry
, char *buffer
, size_t buffer_size
)
208 znode_t
*zp
= ITOZ(dentry
->d_inode
);
209 zfs_sb_t
*zsb
= ZTOZSB(zp
);
210 xattr_filldir_t xf
= { buffer_size
, 0, buffer
, dentry
->d_inode
};
215 rw_enter(&zp
->z_xattr_lock
, RW_READER
);
217 if (zsb
->z_use_sa
&& zp
->z_is_sa
) {
218 error
= zpl_xattr_list_sa(&xf
);
223 error
= zpl_xattr_list_dir(&xf
, cr
);
230 rw_exit(&zp
->z_xattr_lock
);
237 zpl_xattr_get_dir(struct inode
*ip
, const char *name
, void *value
,
238 size_t size
, cred_t
*cr
)
240 struct inode
*dxip
= NULL
;
241 struct inode
*xip
= NULL
;
244 /* Lookup the xattr directory */
245 error
= -zfs_lookup(ip
, NULL
, &dxip
, LOOKUP_XATTR
, cr
, NULL
, NULL
);
249 /* Lookup a specific xattr name in the directory */
250 error
= -zfs_lookup(dxip
, (char *)name
, &xip
, 0, cr
, NULL
, NULL
);
255 error
= i_size_read(xip
);
259 if (size
< i_size_read(xip
)) {
264 error
= zpl_read_common(xip
, value
, size
, 0, UIO_SYSSPACE
, 0, cr
);
276 zpl_xattr_get_sa(struct inode
*ip
, const char *name
, void *value
, size_t size
)
278 znode_t
*zp
= ITOZ(ip
);
283 ASSERT(RW_LOCK_HELD(&zp
->z_xattr_lock
));
285 mutex_enter(&zp
->z_lock
);
286 if (zp
->z_xattr_cached
== NULL
)
287 error
= -zfs_sa_get_xattr(zp
);
288 mutex_exit(&zp
->z_lock
);
293 ASSERT(zp
->z_xattr_cached
);
294 error
= -nvlist_lookup_byte_array(zp
->z_xattr_cached
, name
,
295 &nv_value
, &nv_size
);
305 memcpy(value
, nv_value
, nv_size
);
311 __zpl_xattr_get(struct inode
*ip
, const char *name
, void *value
, size_t size
,
314 znode_t
*zp
= ITOZ(ip
);
315 zfs_sb_t
*zsb
= ZTOZSB(zp
);
318 ASSERT(RW_LOCK_HELD(&zp
->z_xattr_lock
));
320 if (zsb
->z_use_sa
&& zp
->z_is_sa
) {
321 error
= zpl_xattr_get_sa(ip
, name
, value
, size
);
322 if (error
!= -ENOENT
)
326 error
= zpl_xattr_get_dir(ip
, name
, value
, size
, cr
);
328 if (error
== -ENOENT
)
335 zpl_xattr_get(struct inode
*ip
, const char *name
, void *value
, size_t size
)
337 znode_t
*zp
= ITOZ(ip
);
342 rw_enter(&zp
->z_xattr_lock
, RW_READER
);
343 error
= __zpl_xattr_get(ip
, name
, value
, size
, cr
);
344 rw_exit(&zp
->z_xattr_lock
);
351 zpl_xattr_set_dir(struct inode
*ip
, const char *name
, const void *value
,
352 size_t size
, int flags
, cred_t
*cr
)
354 struct inode
*dxip
= NULL
;
355 struct inode
*xip
= NULL
;
358 int lookup_flags
, error
;
359 const int xattr_mode
= S_IFREG
| 0644;
362 * Lookup the xattr directory. When we're adding an entry pass
363 * CREATE_XATTR_DIR to ensure the xattr directory is created.
364 * When removing an entry this flag is not passed to avoid
365 * unnecessarily creating a new xattr directory.
367 lookup_flags
= LOOKUP_XATTR
;
369 lookup_flags
|= CREATE_XATTR_DIR
;
371 error
= -zfs_lookup(ip
, NULL
, &dxip
, lookup_flags
, cr
, NULL
, NULL
);
375 /* Lookup a specific xattr name in the directory */
376 error
= -zfs_lookup(dxip
, (char *)name
, &xip
, 0, cr
, NULL
, NULL
);
377 if (error
&& (error
!= -ENOENT
))
382 /* Remove a specific name xattr when value is set to NULL. */
385 error
= -zfs_remove(dxip
, (char *)name
, cr
);
390 /* Lookup failed create a new xattr. */
392 vap
= kmem_zalloc(sizeof(vattr_t
), KM_SLEEP
);
393 vap
->va_mode
= xattr_mode
;
394 vap
->va_mask
= ATTR_MODE
;
395 vap
->va_uid
= crgetfsuid(cr
);
396 vap
->va_gid
= crgetfsgid(cr
);
398 error
= -zfs_create(dxip
, (char *)name
, vap
, 0, 0644, &xip
,
406 error
= -zfs_freesp(ITOZ(xip
), 0, 0, xattr_mode
, TRUE
);
410 wrote
= zpl_write_common(xip
, value
, size
, 0, UIO_SYSSPACE
, 0, cr
);
416 kmem_free(vap
, sizeof(vattr_t
));
424 if (error
== -ENOENT
)
427 ASSERT3S(error
, <=, 0);
433 zpl_xattr_set_sa(struct inode
*ip
, const char *name
, const void *value
,
434 size_t size
, int flags
, cred_t
*cr
)
436 znode_t
*zp
= ITOZ(ip
);
441 ASSERT(zp
->z_xattr_cached
);
442 nvl
= zp
->z_xattr_cached
;
445 error
= -nvlist_remove(nvl
, name
, DATA_TYPE_BYTE_ARRAY
);
446 if (error
== -ENOENT
)
447 error
= zpl_xattr_set_dir(ip
, name
, NULL
, 0, flags
, cr
);
449 /* Do not allow SA xattrs in symlinks (issue #1648) */
450 if (S_ISLNK(ip
->i_mode
))
453 /* Limited to 32k to keep nvpair memory allocations small */
454 if (size
> DXATTR_MAX_ENTRY_SIZE
)
457 /* Prevent the DXATTR SA from consuming the entire SA region */
458 error
= -nvlist_size(nvl
, &sa_size
, NV_ENCODE_XDR
);
462 if (sa_size
> DXATTR_MAX_SA_SIZE
)
465 error
= -nvlist_add_byte_array(nvl
, name
,
466 (uchar_t
*)value
, size
);
471 /* Update the SA for additions, modifications, and removals. */
473 error
= -zfs_sa_set_xattr(zp
);
475 ASSERT3S(error
, <=, 0);
481 zpl_xattr_set(struct inode
*ip
, const char *name
, const void *value
,
482 size_t size
, int flags
)
484 znode_t
*zp
= ITOZ(ip
);
485 zfs_sb_t
*zsb
= ZTOZSB(zp
);
490 rw_enter(&ITOZ(ip
)->z_xattr_lock
, RW_WRITER
);
493 * Before setting the xattr check to see if it already exists.
494 * This is done to ensure the following optional flags are honored.
496 * XATTR_CREATE: fail if xattr already exists
497 * XATTR_REPLACE: fail if xattr does not exist
499 error
= __zpl_xattr_get(ip
, name
, NULL
, 0, cr
);
501 if (error
!= -ENODATA
)
504 if (flags
& XATTR_REPLACE
)
507 /* The xattr to be removed already doesn't exist */
513 if (flags
& XATTR_CREATE
)
517 /* Preferentially store the xattr as a SA for better performance */
518 if (zsb
->z_use_sa
&& zsb
->z_xattr_sa
&& zp
->z_is_sa
) {
519 error
= zpl_xattr_set_sa(ip
, name
, value
, size
, flags
, cr
);
524 error
= zpl_xattr_set_dir(ip
, name
, value
, size
, flags
, cr
);
526 rw_exit(&ITOZ(ip
)->z_xattr_lock
);
528 ASSERT3S(error
, <=, 0);
534 __zpl_xattr_user_get(struct inode
*ip
, const char *name
,
535 void *value
, size_t size
)
540 if (strcmp(name
, "") == 0)
543 if (!(ITOZSB(ip
)->z_flags
& ZSB_XATTR
))
546 xattr_name
= kmem_asprintf("%s%s", XATTR_USER_PREFIX
, name
);
547 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
552 ZPL_XATTR_GET_WRAPPER(zpl_xattr_user_get
);
555 __zpl_xattr_user_set(struct inode
*ip
, const char *name
,
556 const void *value
, size_t size
, int flags
)
561 if (strcmp(name
, "") == 0)
564 if (!(ITOZSB(ip
)->z_flags
& ZSB_XATTR
))
567 xattr_name
= kmem_asprintf("%s%s", XATTR_USER_PREFIX
, name
);
568 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
573 ZPL_XATTR_SET_WRAPPER(zpl_xattr_user_set
);
575 xattr_handler_t zpl_xattr_user_handler
= {
576 .prefix
= XATTR_USER_PREFIX
,
577 .get
= zpl_xattr_user_get
,
578 .set
= zpl_xattr_user_set
,
582 __zpl_xattr_trusted_get(struct inode
*ip
, const char *name
,
583 void *value
, size_t size
)
588 if (!capable(CAP_SYS_ADMIN
))
591 if (strcmp(name
, "") == 0)
594 xattr_name
= kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX
, name
);
595 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
600 ZPL_XATTR_GET_WRAPPER(zpl_xattr_trusted_get
);
603 __zpl_xattr_trusted_set(struct inode
*ip
, const char *name
,
604 const void *value
, size_t size
, int flags
)
609 if (!capable(CAP_SYS_ADMIN
))
612 if (strcmp(name
, "") == 0)
615 xattr_name
= kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX
, name
);
616 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
621 ZPL_XATTR_SET_WRAPPER(zpl_xattr_trusted_set
);
623 xattr_handler_t zpl_xattr_trusted_handler
= {
624 .prefix
= XATTR_TRUSTED_PREFIX
,
625 .get
= zpl_xattr_trusted_get
,
626 .set
= zpl_xattr_trusted_set
,
630 __zpl_xattr_security_get(struct inode
*ip
, const char *name
,
631 void *value
, size_t size
)
636 if (strcmp(name
, "") == 0)
639 xattr_name
= kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX
, name
);
640 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
645 ZPL_XATTR_GET_WRAPPER(zpl_xattr_security_get
);
648 __zpl_xattr_security_set(struct inode
*ip
, const char *name
,
649 const void *value
, size_t size
, int flags
)
654 if (strcmp(name
, "") == 0)
657 xattr_name
= kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX
, name
);
658 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
663 ZPL_XATTR_SET_WRAPPER(zpl_xattr_security_set
);
665 #ifdef HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY
667 __zpl_xattr_security_init(struct inode
*ip
, const struct xattr
*xattrs
,
670 const struct xattr
*xattr
;
673 for (xattr
= xattrs
; xattr
->name
!= NULL
; xattr
++) {
674 error
= __zpl_xattr_security_set(ip
,
675 xattr
->name
, xattr
->value
, xattr
->value_len
, 0);
685 zpl_xattr_security_init(struct inode
*ip
, struct inode
*dip
,
686 const struct qstr
*qstr
)
688 return security_inode_init_security(ip
, dip
, qstr
,
689 &__zpl_xattr_security_init
, NULL
);
694 zpl_xattr_security_init(struct inode
*ip
, struct inode
*dip
,
695 const struct qstr
*qstr
)
702 error
= zpl_security_inode_init_security(ip
, dip
, qstr
,
703 &name
, &value
, &len
);
705 if (error
== -EOPNOTSUPP
)
710 error
= __zpl_xattr_security_set(ip
, name
, value
, len
, 0);
717 #endif /* HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY */
719 xattr_handler_t zpl_xattr_security_handler
= {
720 .prefix
= XATTR_SECURITY_PREFIX
,
721 .get
= zpl_xattr_security_get
,
722 .set
= zpl_xattr_security_set
,
726 zpl_set_acl(struct inode
*ip
, int type
, struct posix_acl
*acl
)
728 struct super_block
*sb
= ITOZSB(ip
)->z_sb
;
729 char *name
, *value
= NULL
;
733 if (S_ISLNK(ip
->i_mode
))
734 return (-EOPNOTSUPP
);
737 case ACL_TYPE_ACCESS
:
738 name
= POSIX_ACL_XATTR_ACCESS
;
740 zpl_equivmode_t mode
= ip
->i_mode
;
741 error
= posix_acl_equiv_mode(acl
, &mode
);
746 * The mode bits will have been set by
747 * ->zfs_setattr()->zfs_acl_chmod_setattr()
748 * using the ZFS ACL conversion. If they
749 * differ from the Posix ACL conversion dirty
750 * the inode to write the Posix mode bits.
752 if (ip
->i_mode
!= mode
) {
754 ip
->i_ctime
= current_fs_time(sb
);
755 mark_inode_dirty(ip
);
764 case ACL_TYPE_DEFAULT
:
765 name
= POSIX_ACL_XATTR_DEFAULT
;
766 if (!S_ISDIR(ip
->i_mode
))
767 return (acl
? -EACCES
: 0);
775 size
= posix_acl_xattr_size(acl
->a_count
);
776 value
= kmem_alloc(size
, KM_SLEEP
);
778 error
= zpl_acl_to_xattr(acl
, value
, size
);
780 kmem_free(value
, size
);
785 error
= zpl_xattr_set(ip
, name
, value
, size
, 0);
787 kmem_free(value
, size
);
791 zpl_set_cached_acl(ip
, type
, acl
);
793 zpl_forget_cached_acl(ip
, type
);
800 zpl_get_acl(struct inode
*ip
, int type
)
802 struct posix_acl
*acl
;
807 #ifdef HAVE_POSIX_ACL_CACHING
808 acl
= get_cached_acl(ip
, type
);
809 if (acl
!= ACL_NOT_CACHED
)
811 #endif /* HAVE_POSIX_ACL_CACHING */
814 case ACL_TYPE_ACCESS
:
815 name
= POSIX_ACL_XATTR_ACCESS
;
817 case ACL_TYPE_DEFAULT
:
818 name
= POSIX_ACL_XATTR_DEFAULT
;
821 return ERR_PTR(-EINVAL
);
824 size
= zpl_xattr_get(ip
, name
, NULL
, 0);
826 value
= kmem_alloc(size
, KM_PUSHPAGE
);
827 size
= zpl_xattr_get(ip
, name
, value
, size
);
831 acl
= zpl_acl_from_xattr(value
, size
);
832 } else if (size
== -ENODATA
|| size
== -ENOSYS
) {
839 kmem_free(value
, size
);
842 zpl_set_cached_acl(ip
, type
, acl
);
847 #if !defined(HAVE_GET_ACL)
849 __zpl_check_acl(struct inode
*ip
, int mask
)
851 struct posix_acl
*acl
;
854 acl
= zpl_get_acl(ip
, ACL_TYPE_ACCESS
);
856 return (PTR_ERR(acl
));
859 error
= posix_acl_permission(ip
, acl
, mask
);
860 zpl_posix_acl_release(acl
);
867 #if defined(HAVE_CHECK_ACL_WITH_FLAGS)
869 zpl_check_acl(struct inode
*ip
, int mask
, unsigned int flags
)
871 return __zpl_check_acl(ip
, mask
);
873 #elif defined(HAVE_CHECK_ACL)
875 zpl_check_acl(struct inode
*ip
, int mask
)
877 return __zpl_check_acl(ip
, mask
);
879 #elif defined(HAVE_PERMISSION_WITH_NAMEIDATA)
881 zpl_permission(struct inode
*ip
, int mask
, struct nameidata
*nd
)
883 return generic_permission(ip
, mask
, __zpl_check_acl
);
885 #elif defined(HAVE_PERMISSION)
887 zpl_permission(struct inode
*ip
, int mask
)
889 return generic_permission(ip
, mask
, __zpl_check_acl
);
891 #endif /* HAVE_CHECK_ACL | HAVE_PERMISSION */
892 #endif /* !HAVE_GET_ACL */
895 zpl_init_acl(struct inode
*ip
, struct inode
*dir
)
897 struct posix_acl
*acl
= NULL
;
900 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
903 if (!S_ISLNK(ip
->i_mode
)) {
904 if (ITOZSB(ip
)->z_acl_type
== ZFS_ACLTYPE_POSIXACL
) {
905 acl
= zpl_get_acl(dir
, ACL_TYPE_DEFAULT
);
907 return (PTR_ERR(acl
));
911 ip
->i_mode
&= ~current_umask();
912 ip
->i_ctime
= current_fs_time(ITOZSB(ip
)->z_sb
);
913 mark_inode_dirty(ip
);
918 if ((ITOZSB(ip
)->z_acl_type
== ZFS_ACLTYPE_POSIXACL
) && acl
) {
921 if (S_ISDIR(ip
->i_mode
)) {
922 error
= zpl_set_acl(ip
, ACL_TYPE_DEFAULT
, acl
);
928 error
= posix_acl_create(&acl
,GFP_KERNEL
, &mode
);
931 mark_inode_dirty(ip
);
933 error
= zpl_set_acl(ip
, ACL_TYPE_ACCESS
, acl
);
937 zpl_posix_acl_release(acl
);
943 zpl_chmod_acl(struct inode
*ip
)
945 struct posix_acl
*acl
;
948 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
951 if (S_ISLNK(ip
->i_mode
))
952 return (-EOPNOTSUPP
);
954 acl
= zpl_get_acl(ip
, ACL_TYPE_ACCESS
);
955 if (IS_ERR(acl
) || !acl
)
956 return (PTR_ERR(acl
));
958 error
= posix_acl_chmod(&acl
,GFP_KERNEL
, ip
->i_mode
);
960 error
= zpl_set_acl(ip
,ACL_TYPE_ACCESS
, acl
);
962 zpl_posix_acl_release(acl
);
968 zpl_xattr_acl_list(struct inode
*ip
, char *list
, size_t list_size
,
969 const char *name
, size_t name_len
, int type
)
974 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
978 case ACL_TYPE_ACCESS
:
979 xattr_name
= POSIX_ACL_XATTR_ACCESS
;
980 xattr_size
= sizeof(xattr_name
);
982 case ACL_TYPE_DEFAULT
:
983 xattr_name
= POSIX_ACL_XATTR_DEFAULT
;
984 xattr_size
= sizeof(xattr_name
);
990 if (list
&& xattr_size
<= list_size
)
991 memcpy(list
, xattr_name
, xattr_size
);
996 #ifdef HAVE_DENTRY_XATTR_LIST
998 zpl_xattr_acl_list_access(struct dentry
*dentry
, char *list
,
999 size_t list_size
, const char *name
, size_t name_len
, int type
)
1001 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1002 return zpl_xattr_acl_list(dentry
->d_inode
,
1003 list
, list_size
, name
, name_len
, type
);
1007 zpl_xattr_acl_list_default(struct dentry
*dentry
, char *list
,
1008 size_t list_size
, const char *name
, size_t name_len
, int type
)
1010 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1011 return zpl_xattr_acl_list(dentry
->d_inode
,
1012 list
, list_size
, name
, name_len
, type
);
1018 zpl_xattr_acl_list_access(struct inode
*ip
, char *list
, size_t list_size
,
1019 const char *name
, size_t name_len
)
1021 return zpl_xattr_acl_list(ip
,
1022 list
, list_size
, name
, name_len
, ACL_TYPE_ACCESS
);
1026 zpl_xattr_acl_list_default(struct inode
*ip
, char *list
, size_t list_size
,
1027 const char *name
, size_t name_len
)
1029 return zpl_xattr_acl_list(ip
,
1030 list
, list_size
, name
, name_len
, ACL_TYPE_DEFAULT
);
1032 #endif /* HAVE_DENTRY_XATTR_LIST */
1035 zpl_xattr_acl_get(struct inode
*ip
, const char *name
,
1036 void *buffer
, size_t size
, int type
)
1038 struct posix_acl
*acl
;
1041 if (strcmp(name
, "") != 0)
1044 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
1045 return (-EOPNOTSUPP
);
1047 acl
= zpl_get_acl(ip
, type
);
1049 return (PTR_ERR(acl
));
1053 error
= zpl_acl_to_xattr(acl
, buffer
, size
);
1054 zpl_posix_acl_release(acl
);
1059 #ifdef HAVE_DENTRY_XATTR_GET
1061 zpl_xattr_acl_get_access(struct dentry
*dentry
, const char *name
,
1062 void *buffer
, size_t size
, int type
)
1064 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1065 return zpl_xattr_acl_get(dentry
->d_inode
, name
, buffer
, size
, type
);
1069 zpl_xattr_acl_get_default(struct dentry
*dentry
, const char *name
,
1070 void *buffer
, size_t size
, int type
)
1072 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1073 return zpl_xattr_acl_get(dentry
->d_inode
, name
, buffer
, size
, type
);
1079 zpl_xattr_acl_get_access(struct inode
*ip
, const char *name
,
1080 void *buffer
, size_t size
)
1082 return zpl_xattr_acl_get(ip
, name
, buffer
, size
, ACL_TYPE_ACCESS
);
1086 zpl_xattr_acl_get_default(struct inode
*ip
, const char *name
,
1087 void *buffer
, size_t size
)
1089 return zpl_xattr_acl_get(ip
, name
, buffer
, size
, ACL_TYPE_DEFAULT
);
1091 #endif /* HAVE_DENTRY_XATTR_GET */
1094 zpl_xattr_acl_set(struct inode
*ip
, const char *name
,
1095 const void *value
, size_t size
, int flags
, int type
)
1097 struct posix_acl
*acl
;
1100 if (strcmp(name
, "") != 0)
1103 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
1104 return (-EOPNOTSUPP
);
1106 if (!zpl_inode_owner_or_capable(ip
))
1110 acl
= zpl_acl_from_xattr(value
, size
);
1112 return (PTR_ERR(acl
));
1114 error
= posix_acl_valid(acl
);
1116 zpl_posix_acl_release(acl
);
1124 error
= zpl_set_acl(ip
, type
, acl
);
1125 zpl_posix_acl_release(acl
);
1130 #ifdef HAVE_DENTRY_XATTR_SET
1132 zpl_xattr_acl_set_access(struct dentry
*dentry
, const char *name
,
1133 const void *value
, size_t size
, int flags
, int type
)
1135 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1136 return zpl_xattr_acl_set(dentry
->d_inode
,
1137 name
, value
, size
, flags
, type
);
1141 zpl_xattr_acl_set_default(struct dentry
*dentry
, const char *name
,
1142 const void *value
, size_t size
,int flags
, int type
)
1144 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1145 return zpl_xattr_acl_set(dentry
->d_inode
,
1146 name
, value
, size
, flags
, type
);
1152 zpl_xattr_acl_set_access(struct inode
*ip
, const char *name
,
1153 const void *value
, size_t size
, int flags
)
1155 return zpl_xattr_acl_set(ip
,
1156 name
, value
, size
, flags
, ACL_TYPE_ACCESS
);
1160 zpl_xattr_acl_set_default(struct inode
*ip
, const char *name
,
1161 const void *value
, size_t size
, int flags
)
1163 return zpl_xattr_acl_set(ip
,
1164 name
, value
, size
, flags
, ACL_TYPE_DEFAULT
);
1166 #endif /* HAVE_DENTRY_XATTR_SET */
1168 struct xattr_handler zpl_xattr_acl_access_handler
=
1170 .prefix
= POSIX_ACL_XATTR_ACCESS
,
1171 .list
= zpl_xattr_acl_list_access
,
1172 .get
= zpl_xattr_acl_get_access
,
1173 .set
= zpl_xattr_acl_set_access
,
1174 #ifdef HAVE_DENTRY_XATTR_LIST
1175 .flags
= ACL_TYPE_ACCESS
,
1176 #endif /* HAVE_DENTRY_XATTR_LIST */
1179 struct xattr_handler zpl_xattr_acl_default_handler
=
1181 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
1182 .list
= zpl_xattr_acl_list_default
,
1183 .get
= zpl_xattr_acl_get_default
,
1184 .set
= zpl_xattr_acl_set_default
,
1185 #ifdef HAVE_DENTRY_XATTR_LIST
1186 .flags
= ACL_TYPE_DEFAULT
,
1187 #endif /* HAVE_DENTRY_XATTR_LIST */
1190 xattr_handler_t
*zpl_xattr_handlers
[] = {
1191 &zpl_xattr_security_handler
,
1192 &zpl_xattr_trusted_handler
,
1193 &zpl_xattr_user_handler
,
1194 &zpl_xattr_acl_access_handler
,
1195 &zpl_xattr_acl_default_handler
,