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
) == 0)
98 if (!(ITOZSB(xf
->inode
)->z_flags
& ZSB_XATTR
))
101 if (strncmp(name
, XATTR_TRUSTED_PREFIX
, XATTR_TRUSTED_PREFIX_LEN
) == 0)
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 /* Limited to 32k to keep nvpair memory allocations small */
450 if (size
> DXATTR_MAX_ENTRY_SIZE
)
453 /* Prevent the DXATTR SA from consuming the entire SA region */
454 error
= -nvlist_size(nvl
, &sa_size
, NV_ENCODE_XDR
);
458 if (sa_size
> DXATTR_MAX_SA_SIZE
)
461 error
= -nvlist_add_byte_array(nvl
, name
,
462 (uchar_t
*)value
, size
);
467 /* Update the SA for additions, modifications, and removals. */
469 error
= -zfs_sa_set_xattr(zp
);
471 ASSERT3S(error
, <=, 0);
477 zpl_xattr_set(struct inode
*ip
, const char *name
, const void *value
,
478 size_t size
, int flags
)
480 znode_t
*zp
= ITOZ(ip
);
481 zfs_sb_t
*zsb
= ZTOZSB(zp
);
486 rw_enter(&ITOZ(ip
)->z_xattr_lock
, RW_WRITER
);
489 * Before setting the xattr check to see if it already exists.
490 * This is done to ensure the following optional flags are honored.
492 * XATTR_CREATE: fail if xattr already exists
493 * XATTR_REPLACE: fail if xattr does not exist
495 error
= __zpl_xattr_get(ip
, name
, NULL
, 0, cr
);
497 if (error
!= -ENODATA
)
500 if (flags
& XATTR_REPLACE
)
503 /* The xattr to be removed already doesn't exist */
509 if (flags
& XATTR_CREATE
)
513 /* Preferentially store the xattr as a SA for better performance */
514 if (zsb
->z_use_sa
&& zsb
->z_xattr_sa
&& zp
->z_is_sa
) {
515 error
= zpl_xattr_set_sa(ip
, name
, value
, size
, flags
, cr
);
520 error
= zpl_xattr_set_dir(ip
, name
, value
, size
, flags
, cr
);
522 rw_exit(&ITOZ(ip
)->z_xattr_lock
);
524 ASSERT3S(error
, <=, 0);
530 __zpl_xattr_user_get(struct inode
*ip
, const char *name
,
531 void *value
, size_t size
)
536 if (strcmp(name
, "") == 0)
539 if (!(ITOZSB(ip
)->z_flags
& ZSB_XATTR
))
540 return (-EOPNOTSUPP
);
542 xattr_name
= kmem_asprintf("%s%s", XATTR_USER_PREFIX
, name
);
543 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
548 ZPL_XATTR_GET_WRAPPER(zpl_xattr_user_get
);
551 __zpl_xattr_user_set(struct inode
*ip
, const char *name
,
552 const void *value
, size_t size
, int flags
)
557 if (strcmp(name
, "") == 0)
560 if (!(ITOZSB(ip
)->z_flags
& ZSB_XATTR
))
561 return (-EOPNOTSUPP
);
563 xattr_name
= kmem_asprintf("%s%s", XATTR_USER_PREFIX
, name
);
564 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
569 ZPL_XATTR_SET_WRAPPER(zpl_xattr_user_set
);
571 xattr_handler_t zpl_xattr_user_handler
= {
572 .prefix
= XATTR_USER_PREFIX
,
573 .get
= zpl_xattr_user_get
,
574 .set
= zpl_xattr_user_set
,
578 __zpl_xattr_trusted_get(struct inode
*ip
, const char *name
,
579 void *value
, size_t size
)
584 if (!capable(CAP_SYS_ADMIN
))
587 if (strcmp(name
, "") == 0)
590 xattr_name
= kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX
, name
);
591 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
596 ZPL_XATTR_GET_WRAPPER(zpl_xattr_trusted_get
);
599 __zpl_xattr_trusted_set(struct inode
*ip
, const char *name
,
600 const void *value
, size_t size
, int flags
)
605 if (!capable(CAP_SYS_ADMIN
))
608 if (strcmp(name
, "") == 0)
611 xattr_name
= kmem_asprintf("%s%s", XATTR_TRUSTED_PREFIX
, name
);
612 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
617 ZPL_XATTR_SET_WRAPPER(zpl_xattr_trusted_set
);
619 xattr_handler_t zpl_xattr_trusted_handler
= {
620 .prefix
= XATTR_TRUSTED_PREFIX
,
621 .get
= zpl_xattr_trusted_get
,
622 .set
= zpl_xattr_trusted_set
,
626 __zpl_xattr_security_get(struct inode
*ip
, const char *name
,
627 void *value
, size_t size
)
632 if (strcmp(name
, "") == 0)
635 xattr_name
= kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX
, name
);
636 error
= zpl_xattr_get(ip
, xattr_name
, value
, size
);
641 ZPL_XATTR_GET_WRAPPER(zpl_xattr_security_get
);
644 __zpl_xattr_security_set(struct inode
*ip
, const char *name
,
645 const void *value
, size_t size
, int flags
)
650 if (strcmp(name
, "") == 0)
653 xattr_name
= kmem_asprintf("%s%s", XATTR_SECURITY_PREFIX
, name
);
654 error
= zpl_xattr_set(ip
, xattr_name
, value
, size
, flags
);
659 ZPL_XATTR_SET_WRAPPER(zpl_xattr_security_set
);
661 #ifdef HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY
663 __zpl_xattr_security_init(struct inode
*ip
, const struct xattr
*xattrs
,
666 const struct xattr
*xattr
;
669 for (xattr
= xattrs
; xattr
->name
!= NULL
; xattr
++) {
670 error
= __zpl_xattr_security_set(ip
,
671 xattr
->name
, xattr
->value
, xattr
->value_len
, 0);
681 zpl_xattr_security_init(struct inode
*ip
, struct inode
*dip
,
682 const struct qstr
*qstr
)
684 return security_inode_init_security(ip
, dip
, qstr
,
685 &__zpl_xattr_security_init
, NULL
);
690 zpl_xattr_security_init(struct inode
*ip
, struct inode
*dip
,
691 const struct qstr
*qstr
)
698 error
= zpl_security_inode_init_security(ip
, dip
, qstr
,
699 &name
, &value
, &len
);
701 if (error
== -EOPNOTSUPP
)
707 error
= __zpl_xattr_security_set(ip
, name
, value
, len
, 0);
714 #endif /* HAVE_CALLBACK_SECURITY_INODE_INIT_SECURITY */
716 xattr_handler_t zpl_xattr_security_handler
= {
717 .prefix
= XATTR_SECURITY_PREFIX
,
718 .get
= zpl_xattr_security_get
,
719 .set
= zpl_xattr_security_set
,
722 #ifdef CONFIG_FS_POSIX_ACL
725 zpl_set_acl(struct inode
*ip
, int type
, struct posix_acl
*acl
)
727 struct super_block
*sb
= ITOZSB(ip
)->z_sb
;
728 char *name
, *value
= NULL
;
732 if (S_ISLNK(ip
->i_mode
))
733 return (-EOPNOTSUPP
);
736 case ACL_TYPE_ACCESS
:
737 name
= POSIX_ACL_XATTR_ACCESS
;
739 zpl_equivmode_t mode
= ip
->i_mode
;
740 error
= posix_acl_equiv_mode(acl
, &mode
);
745 * The mode bits will have been set by
746 * ->zfs_setattr()->zfs_acl_chmod_setattr()
747 * using the ZFS ACL conversion. If they
748 * differ from the Posix ACL conversion dirty
749 * the inode to write the Posix mode bits.
751 if (ip
->i_mode
!= mode
) {
753 ip
->i_ctime
= current_fs_time(sb
);
754 mark_inode_dirty(ip
);
763 case ACL_TYPE_DEFAULT
:
764 name
= POSIX_ACL_XATTR_DEFAULT
;
765 if (!S_ISDIR(ip
->i_mode
))
766 return (acl
? -EACCES
: 0);
774 size
= posix_acl_xattr_size(acl
->a_count
);
775 value
= kmem_alloc(size
, KM_SLEEP
);
777 error
= zpl_acl_to_xattr(acl
, value
, size
);
779 kmem_free(value
, size
);
784 error
= zpl_xattr_set(ip
, name
, value
, size
, 0);
786 kmem_free(value
, size
);
790 zpl_set_cached_acl(ip
, type
, acl
);
792 zpl_forget_cached_acl(ip
, type
);
799 zpl_get_acl(struct inode
*ip
, int type
)
801 struct posix_acl
*acl
;
806 #ifdef HAVE_POSIX_ACL_CACHING
807 acl
= get_cached_acl(ip
, type
);
808 if (acl
!= ACL_NOT_CACHED
)
810 #endif /* HAVE_POSIX_ACL_CACHING */
813 case ACL_TYPE_ACCESS
:
814 name
= POSIX_ACL_XATTR_ACCESS
;
816 case ACL_TYPE_DEFAULT
:
817 name
= POSIX_ACL_XATTR_DEFAULT
;
820 return (ERR_PTR(-EINVAL
));
823 size
= zpl_xattr_get(ip
, name
, NULL
, 0);
825 value
= kmem_alloc(size
, KM_PUSHPAGE
);
826 size
= zpl_xattr_get(ip
, name
, value
, size
);
830 acl
= zpl_acl_from_xattr(value
, size
);
831 } else if (size
== -ENODATA
|| size
== -ENOSYS
) {
838 kmem_free(value
, size
);
841 zpl_set_cached_acl(ip
, type
, acl
);
846 #if !defined(HAVE_GET_ACL)
848 __zpl_check_acl(struct inode
*ip
, int mask
)
850 struct posix_acl
*acl
;
853 acl
= zpl_get_acl(ip
, ACL_TYPE_ACCESS
);
855 return (PTR_ERR(acl
));
858 error
= posix_acl_permission(ip
, acl
, mask
);
859 zpl_posix_acl_release(acl
);
866 #if defined(HAVE_CHECK_ACL_WITH_FLAGS)
868 zpl_check_acl(struct inode
*ip
, int mask
, unsigned int flags
)
870 return (__zpl_check_acl(ip
, mask
));
872 #elif defined(HAVE_CHECK_ACL)
874 zpl_check_acl(struct inode
*ip
, int mask
)
876 return (__zpl_check_acl(ip
, mask
));
878 #elif defined(HAVE_PERMISSION_WITH_NAMEIDATA)
880 zpl_permission(struct inode
*ip
, int mask
, struct nameidata
*nd
)
882 return (generic_permission(ip
, mask
, __zpl_check_acl
));
884 #elif defined(HAVE_PERMISSION)
886 zpl_permission(struct inode
*ip
, int mask
)
888 return (generic_permission(ip
, mask
, __zpl_check_acl
));
890 #endif /* HAVE_CHECK_ACL | HAVE_PERMISSION */
891 #endif /* !HAVE_GET_ACL */
894 zpl_init_acl(struct inode
*ip
, struct inode
*dir
)
896 struct posix_acl
*acl
= NULL
;
899 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
902 if (!S_ISLNK(ip
->i_mode
)) {
903 if (ITOZSB(ip
)->z_acl_type
== ZFS_ACLTYPE_POSIXACL
) {
904 acl
= zpl_get_acl(dir
, ACL_TYPE_DEFAULT
);
906 return (PTR_ERR(acl
));
910 ip
->i_mode
&= ~current_umask();
911 ip
->i_ctime
= current_fs_time(ITOZSB(ip
)->z_sb
);
912 mark_inode_dirty(ip
);
917 if ((ITOZSB(ip
)->z_acl_type
== ZFS_ACLTYPE_POSIXACL
) && acl
) {
920 if (S_ISDIR(ip
->i_mode
)) {
921 error
= zpl_set_acl(ip
, ACL_TYPE_DEFAULT
, acl
);
927 error
= posix_acl_create(&acl
, GFP_KERNEL
, &mode
);
930 mark_inode_dirty(ip
);
932 error
= zpl_set_acl(ip
, ACL_TYPE_ACCESS
, acl
);
936 zpl_posix_acl_release(acl
);
942 zpl_chmod_acl(struct inode
*ip
)
944 struct posix_acl
*acl
;
947 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
950 if (S_ISLNK(ip
->i_mode
))
951 return (-EOPNOTSUPP
);
953 acl
= zpl_get_acl(ip
, ACL_TYPE_ACCESS
);
954 if (IS_ERR(acl
) || !acl
)
955 return (PTR_ERR(acl
));
957 error
= posix_acl_chmod(&acl
, GFP_KERNEL
, ip
->i_mode
);
959 error
= zpl_set_acl(ip
, ACL_TYPE_ACCESS
, acl
);
961 zpl_posix_acl_release(acl
);
967 zpl_xattr_acl_list(struct inode
*ip
, char *list
, size_t list_size
,
968 const char *name
, size_t name_len
, int type
)
973 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
977 case ACL_TYPE_ACCESS
:
978 xattr_name
= POSIX_ACL_XATTR_ACCESS
;
979 xattr_size
= sizeof (xattr_name
);
981 case ACL_TYPE_DEFAULT
:
982 xattr_name
= POSIX_ACL_XATTR_DEFAULT
;
983 xattr_size
= sizeof (xattr_name
);
989 if (list
&& xattr_size
<= list_size
)
990 memcpy(list
, xattr_name
, xattr_size
);
995 #ifdef HAVE_DENTRY_XATTR_LIST
997 zpl_xattr_acl_list_access(struct dentry
*dentry
, char *list
,
998 size_t list_size
, const char *name
, size_t name_len
, int type
)
1000 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1001 return zpl_xattr_acl_list(dentry
->d_inode
,
1002 list
, list_size
, name
, name_len
, type
);
1006 zpl_xattr_acl_list_default(struct dentry
*dentry
, char *list
,
1007 size_t list_size
, const char *name
, size_t name_len
, int type
)
1009 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1010 return zpl_xattr_acl_list(dentry
->d_inode
,
1011 list
, list_size
, name
, name_len
, type
);
1017 zpl_xattr_acl_list_access(struct inode
*ip
, char *list
, size_t list_size
,
1018 const char *name
, size_t name_len
)
1020 return zpl_xattr_acl_list(ip
,
1021 list
, list_size
, name
, name_len
, ACL_TYPE_ACCESS
);
1025 zpl_xattr_acl_list_default(struct inode
*ip
, char *list
, size_t list_size
,
1026 const char *name
, size_t name_len
)
1028 return zpl_xattr_acl_list(ip
,
1029 list
, list_size
, name
, name_len
, ACL_TYPE_DEFAULT
);
1031 #endif /* HAVE_DENTRY_XATTR_LIST */
1034 zpl_xattr_acl_get(struct inode
*ip
, const char *name
,
1035 void *buffer
, size_t size
, int type
)
1037 struct posix_acl
*acl
;
1040 if (strcmp(name
, "") != 0)
1043 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
1044 return (-EOPNOTSUPP
);
1046 acl
= zpl_get_acl(ip
, type
);
1048 return (PTR_ERR(acl
));
1052 error
= zpl_acl_to_xattr(acl
, buffer
, size
);
1053 zpl_posix_acl_release(acl
);
1058 #ifdef HAVE_DENTRY_XATTR_GET
1060 zpl_xattr_acl_get_access(struct dentry
*dentry
, const char *name
,
1061 void *buffer
, size_t size
, int type
)
1063 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1064 return (zpl_xattr_acl_get(dentry
->d_inode
, name
, buffer
, size
, type
));
1068 zpl_xattr_acl_get_default(struct dentry
*dentry
, const char *name
,
1069 void *buffer
, size_t size
, int type
)
1071 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1072 return (zpl_xattr_acl_get(dentry
->d_inode
, name
, buffer
, size
, type
));
1078 zpl_xattr_acl_get_access(struct inode
*ip
, const char *name
,
1079 void *buffer
, size_t size
)
1081 return (zpl_xattr_acl_get(ip
, name
, buffer
, size
, ACL_TYPE_ACCESS
));
1085 zpl_xattr_acl_get_default(struct inode
*ip
, const char *name
,
1086 void *buffer
, size_t size
)
1088 return (zpl_xattr_acl_get(ip
, name
, buffer
, size
, ACL_TYPE_DEFAULT
));
1090 #endif /* HAVE_DENTRY_XATTR_GET */
1093 zpl_xattr_acl_set(struct inode
*ip
, const char *name
,
1094 const void *value
, size_t size
, int flags
, int type
)
1096 struct posix_acl
*acl
;
1099 if (strcmp(name
, "") != 0)
1102 if (ITOZSB(ip
)->z_acl_type
!= ZFS_ACLTYPE_POSIXACL
)
1103 return (-EOPNOTSUPP
);
1105 if (!zpl_inode_owner_or_capable(ip
))
1109 acl
= zpl_acl_from_xattr(value
, size
);
1111 return (PTR_ERR(acl
));
1113 error
= posix_acl_valid(acl
);
1115 zpl_posix_acl_release(acl
);
1123 error
= zpl_set_acl(ip
, type
, acl
);
1124 zpl_posix_acl_release(acl
);
1129 #ifdef HAVE_DENTRY_XATTR_SET
1131 zpl_xattr_acl_set_access(struct dentry
*dentry
, const char *name
,
1132 const void *value
, size_t size
, int flags
, int type
)
1134 ASSERT3S(type
, ==, ACL_TYPE_ACCESS
);
1135 return (zpl_xattr_acl_set(dentry
->d_inode
,
1136 name
, value
, size
, flags
, type
));
1140 zpl_xattr_acl_set_default(struct dentry
*dentry
, const char *name
,
1141 const void *value
, size_t size
, int flags
, int type
)
1143 ASSERT3S(type
, ==, ACL_TYPE_DEFAULT
);
1144 return zpl_xattr_acl_set(dentry
->d_inode
,
1145 name
, value
, size
, flags
, type
);
1151 zpl_xattr_acl_set_access(struct inode
*ip
, const char *name
,
1152 const void *value
, size_t size
, int flags
)
1154 return zpl_xattr_acl_set(ip
,
1155 name
, value
, size
, flags
, ACL_TYPE_ACCESS
);
1159 zpl_xattr_acl_set_default(struct inode
*ip
, const char *name
,
1160 const void *value
, size_t size
, int flags
)
1162 return zpl_xattr_acl_set(ip
,
1163 name
, value
, size
, flags
, ACL_TYPE_DEFAULT
);
1165 #endif /* HAVE_DENTRY_XATTR_SET */
1167 struct xattr_handler zpl_xattr_acl_access_handler
=
1169 .prefix
= POSIX_ACL_XATTR_ACCESS
,
1170 .list
= zpl_xattr_acl_list_access
,
1171 .get
= zpl_xattr_acl_get_access
,
1172 .set
= zpl_xattr_acl_set_access
,
1173 #ifdef HAVE_DENTRY_XATTR_LIST
1174 .flags
= ACL_TYPE_ACCESS
,
1175 #endif /* HAVE_DENTRY_XATTR_LIST */
1178 struct xattr_handler zpl_xattr_acl_default_handler
=
1180 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
1181 .list
= zpl_xattr_acl_list_default
,
1182 .get
= zpl_xattr_acl_get_default
,
1183 .set
= zpl_xattr_acl_set_default
,
1184 #ifdef HAVE_DENTRY_XATTR_LIST
1185 .flags
= ACL_TYPE_DEFAULT
,
1186 #endif /* HAVE_DENTRY_XATTR_LIST */
1189 #endif /* CONFIG_FS_POSIX_ACL */
1191 xattr_handler_t
*zpl_xattr_handlers
[] = {
1192 &zpl_xattr_security_handler
,
1193 &zpl_xattr_trusted_handler
,
1194 &zpl_xattr_user_handler
,
1195 #ifdef CONFIG_FS_POSIX_ACL
1196 &zpl_xattr_acl_access_handler
,
1197 &zpl_xattr_acl_default_handler
,
1198 #endif /* CONFIG_FS_POSIX_ACL */