tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

posix acls: Remove duplicate xattr name definitions

Remove POSIX_ACL_XATTR_{ACCESS,DEFAULT} and GFS2_POSIX_ACL_{ACCESS,DEFAULT}
and replace them with the definitions in <include/uapi/linux/xattr.h>.

Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>
Reviewed-by: James Morris <james.l.morris@oracle.com>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

authored by

Andreas Gruenbacher and committed by
Al Viro 97d79299 44cb0d3f

+55 -61
+2 -2
drivers/staging/lustre/lustre/llite/xattr.c
··· 60 60 static 61 61 int get_xattr_type(const char *name) 62 62 { 63 - if (!strcmp(name, POSIX_ACL_XATTR_ACCESS)) 63 + if (!strcmp(name, XATTR_NAME_POSIX_ACL_ACCESS)) 64 64 return XATTR_ACL_ACCESS_T; 65 65 66 - if (!strcmp(name, POSIX_ACL_XATTR_DEFAULT)) 66 + if (!strcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT)) 67 67 return XATTR_ACL_DEFAULT_T; 68 68 69 69 if (!strncmp(name, XATTR_USER_PREFIX,
+6 -6
fs/9p/acl.c
··· 67 67 return 0; 68 68 } 69 69 /* get the default/access acl values and cache them */ 70 - dacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_DEFAULT); 71 - pacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_ACCESS); 70 + dacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_DEFAULT); 71 + pacl = __v9fs_get_acl(fid, XATTR_NAME_POSIX_ACL_ACCESS); 72 72 73 73 if (!IS_ERR(dacl) && !IS_ERR(pacl)) { 74 74 set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl); ··· 133 133 goto err_free_out; 134 134 switch (type) { 135 135 case ACL_TYPE_ACCESS: 136 - name = POSIX_ACL_XATTR_ACCESS; 136 + name = XATTR_NAME_POSIX_ACL_ACCESS; 137 137 break; 138 138 case ACL_TYPE_DEFAULT: 139 - name = POSIX_ACL_XATTR_DEFAULT; 139 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 140 140 break; 141 141 default: 142 142 BUG(); ··· 328 328 } 329 329 330 330 const struct xattr_handler v9fs_xattr_acl_access_handler = { 331 - .prefix = POSIX_ACL_XATTR_ACCESS, 331 + .prefix = XATTR_NAME_POSIX_ACL_ACCESS, 332 332 .flags = ACL_TYPE_ACCESS, 333 333 .get = v9fs_xattr_get_acl, 334 334 .set = v9fs_xattr_set_acl, 335 335 }; 336 336 337 337 const struct xattr_handler v9fs_xattr_acl_default_handler = { 338 - .prefix = POSIX_ACL_XATTR_DEFAULT, 338 + .prefix = XATTR_NAME_POSIX_ACL_DEFAULT, 339 339 .flags = ACL_TYPE_DEFAULT, 340 340 .get = v9fs_xattr_get_acl, 341 341 .set = v9fs_xattr_set_acl,
+4 -4
fs/btrfs/acl.c
··· 37 37 38 38 switch (type) { 39 39 case ACL_TYPE_ACCESS: 40 - name = POSIX_ACL_XATTR_ACCESS; 40 + name = XATTR_NAME_POSIX_ACL_ACCESS; 41 41 break; 42 42 case ACL_TYPE_DEFAULT: 43 - name = POSIX_ACL_XATTR_DEFAULT; 43 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 44 44 break; 45 45 default: 46 46 BUG(); ··· 81 81 82 82 switch (type) { 83 83 case ACL_TYPE_ACCESS: 84 - name = POSIX_ACL_XATTR_ACCESS; 84 + name = XATTR_NAME_POSIX_ACL_ACCESS; 85 85 if (acl) { 86 86 ret = posix_acl_equiv_mode(acl, &inode->i_mode); 87 87 if (ret < 0) ··· 94 94 case ACL_TYPE_DEFAULT: 95 95 if (!S_ISDIR(inode->i_mode)) 96 96 return acl ? -EINVAL : 0; 97 - name = POSIX_ACL_XATTR_DEFAULT; 97 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 98 98 break; 99 99 default: 100 100 return -EINVAL;
+4 -4
fs/btrfs/inode.c
··· 3550 3550 int scanned = 0; 3551 3551 3552 3552 if (!xattr_access) { 3553 - xattr_access = btrfs_name_hash(POSIX_ACL_XATTR_ACCESS, 3554 - strlen(POSIX_ACL_XATTR_ACCESS)); 3555 - xattr_default = btrfs_name_hash(POSIX_ACL_XATTR_DEFAULT, 3556 - strlen(POSIX_ACL_XATTR_DEFAULT)); 3553 + xattr_access = btrfs_name_hash(XATTR_NAME_POSIX_ACL_ACCESS, 3554 + strlen(XATTR_NAME_POSIX_ACL_ACCESS)); 3555 + xattr_default = btrfs_name_hash(XATTR_NAME_POSIX_ACL_DEFAULT, 3556 + strlen(XATTR_NAME_POSIX_ACL_DEFAULT)); 3557 3557 } 3558 3558 3559 3559 slot++;
+8 -8
fs/ceph/acl.c
··· 49 49 50 50 switch (type) { 51 51 case ACL_TYPE_ACCESS: 52 - name = POSIX_ACL_XATTR_ACCESS; 52 + name = XATTR_NAME_POSIX_ACL_ACCESS; 53 53 break; 54 54 case ACL_TYPE_DEFAULT: 55 - name = POSIX_ACL_XATTR_DEFAULT; 55 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 56 56 break; 57 57 default: 58 58 BUG(); ··· 92 92 93 93 switch (type) { 94 94 case ACL_TYPE_ACCESS: 95 - name = POSIX_ACL_XATTR_ACCESS; 95 + name = XATTR_NAME_POSIX_ACL_ACCESS; 96 96 if (acl) { 97 97 ret = posix_acl_equiv_mode(acl, &new_mode); 98 98 if (ret < 0) ··· 106 106 ret = acl ? -EINVAL : 0; 107 107 goto out; 108 108 } 109 - name = POSIX_ACL_XATTR_DEFAULT; 109 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 110 110 break; 111 111 default: 112 112 ret = -EINVAL; ··· 202 202 ceph_pagelist_encode_32(pagelist, acl && default_acl ? 2 : 1); 203 203 204 204 if (acl) { 205 - size_t len = strlen(POSIX_ACL_XATTR_ACCESS); 205 + size_t len = strlen(XATTR_NAME_POSIX_ACL_ACCESS); 206 206 err = ceph_pagelist_reserve(pagelist, len + val_size1 + 8); 207 207 if (err) 208 208 goto out_err; 209 - ceph_pagelist_encode_string(pagelist, POSIX_ACL_XATTR_ACCESS, 209 + ceph_pagelist_encode_string(pagelist, XATTR_NAME_POSIX_ACL_ACCESS, 210 210 len); 211 211 err = posix_acl_to_xattr(&init_user_ns, acl, 212 212 tmp_buf, val_size1); ··· 216 216 ceph_pagelist_append(pagelist, tmp_buf, val_size1); 217 217 } 218 218 if (default_acl) { 219 - size_t len = strlen(POSIX_ACL_XATTR_DEFAULT); 219 + size_t len = strlen(XATTR_NAME_POSIX_ACL_DEFAULT); 220 220 err = ceph_pagelist_reserve(pagelist, len + val_size2 + 8); 221 221 if (err) 222 222 goto out_err; 223 223 err = ceph_pagelist_encode_string(pagelist, 224 - POSIX_ACL_XATTR_DEFAULT, len); 224 + XATTR_NAME_POSIX_ACL_DEFAULT, len); 225 225 err = posix_acl_to_xattr(&init_user_ns, default_acl, 226 226 tmp_buf, val_size2); 227 227 if (err < 0)
+8 -8
fs/cifs/xattr.c
··· 190 190 #endif /* CONFIG_CIFS_ACL */ 191 191 } else { 192 192 int temp; 193 - temp = strncmp(ea_name, POSIX_ACL_XATTR_ACCESS, 194 - strlen(POSIX_ACL_XATTR_ACCESS)); 193 + temp = strncmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS, 194 + strlen(XATTR_NAME_POSIX_ACL_ACCESS)); 195 195 if (temp == 0) { 196 196 #ifdef CONFIG_CIFS_POSIX 197 197 if (sb->s_flags & MS_POSIXACL) ··· 203 203 #else 204 204 cifs_dbg(FYI, "set POSIX ACL not supported\n"); 205 205 #endif 206 - } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT, 207 - strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) { 206 + } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT, 207 + strlen(XATTR_NAME_POSIX_ACL_DEFAULT)) == 0) { 208 208 #ifdef CONFIG_CIFS_POSIX 209 209 if (sb->s_flags & MS_POSIXACL) 210 210 rc = CIFSSMBSetPosixACL(xid, pTcon, full_path, ··· 292 292 rc = pTcon->ses->server->ops->query_all_EAs(xid, pTcon, 293 293 full_path, ea_name, ea_value, buf_size, 294 294 cifs_sb->local_nls, cifs_remap(cifs_sb)); 295 - } else if (strncmp(ea_name, POSIX_ACL_XATTR_ACCESS, 296 - strlen(POSIX_ACL_XATTR_ACCESS)) == 0) { 295 + } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_ACCESS, 296 + strlen(XATTR_NAME_POSIX_ACL_ACCESS)) == 0) { 297 297 #ifdef CONFIG_CIFS_POSIX 298 298 if (sb->s_flags & MS_POSIXACL) 299 299 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path, ··· 303 303 #else 304 304 cifs_dbg(FYI, "Query POSIX ACL not supported yet\n"); 305 305 #endif /* CONFIG_CIFS_POSIX */ 306 - } else if (strncmp(ea_name, POSIX_ACL_XATTR_DEFAULT, 307 - strlen(POSIX_ACL_XATTR_DEFAULT)) == 0) { 306 + } else if (strncmp(ea_name, XATTR_NAME_POSIX_ACL_DEFAULT, 307 + strlen(XATTR_NAME_POSIX_ACL_DEFAULT)) == 0) { 308 308 #ifdef CONFIG_CIFS_POSIX 309 309 if (sb->s_flags & MS_POSIXACL) 310 310 rc = CIFSSMBGetPosixACL(xid, pTcon, full_path,
+2 -2
fs/gfs2/acl.c
··· 31 31 { 32 32 switch (type) { 33 33 case ACL_TYPE_ACCESS: 34 - return GFS2_POSIX_ACL_ACCESS; 34 + return XATTR_POSIX_ACL_ACCESS; 35 35 case ACL_TYPE_DEFAULT: 36 - return GFS2_POSIX_ACL_DEFAULT; 36 + return XATTR_POSIX_ACL_DEFAULT; 37 37 } 38 38 return NULL; 39 39 }
-2
fs/gfs2/acl.h
··· 12 12 13 13 #include "incore.h" 14 14 15 - #define GFS2_POSIX_ACL_ACCESS "posix_acl_access" 16 - #define GFS2_POSIX_ACL_DEFAULT "posix_acl_default" 17 15 #define GFS2_ACL_MAX_ENTRIES(sdp) ((300 << (sdp)->sd_sb.sb_bsize_shift) >> 12) 18 16 19 17 extern struct posix_acl *gfs2_get_acl(struct inode *inode, int type);
+4 -4
fs/hfsplus/posix_acl.c
··· 21 21 22 22 switch (type) { 23 23 case ACL_TYPE_ACCESS: 24 - xattr_name = POSIX_ACL_XATTR_ACCESS; 24 + xattr_name = XATTR_NAME_POSIX_ACL_ACCESS; 25 25 break; 26 26 case ACL_TYPE_DEFAULT: 27 - xattr_name = POSIX_ACL_XATTR_DEFAULT; 27 + xattr_name = XATTR_NAME_POSIX_ACL_DEFAULT; 28 28 break; 29 29 default: 30 30 return ERR_PTR(-EINVAL); ··· 66 66 67 67 switch (type) { 68 68 case ACL_TYPE_ACCESS: 69 - xattr_name = POSIX_ACL_XATTR_ACCESS; 69 + xattr_name = XATTR_NAME_POSIX_ACL_ACCESS; 70 70 if (acl) { 71 71 err = posix_acl_equiv_mode(acl, &inode->i_mode); 72 72 if (err < 0) ··· 76 76 break; 77 77 78 78 case ACL_TYPE_DEFAULT: 79 - xattr_name = POSIX_ACL_XATTR_DEFAULT; 79 + xattr_name = XATTR_NAME_POSIX_ACL_DEFAULT; 80 80 if (!S_ISDIR(inode->i_mode)) 81 81 return acl ? -EACCES : 0; 82 82 break;
+4 -4
fs/jfs/acl.c
··· 40 40 41 41 switch(type) { 42 42 case ACL_TYPE_ACCESS: 43 - ea_name = POSIX_ACL_XATTR_ACCESS; 43 + ea_name = XATTR_NAME_POSIX_ACL_ACCESS; 44 44 break; 45 45 case ACL_TYPE_DEFAULT: 46 - ea_name = POSIX_ACL_XATTR_DEFAULT; 46 + ea_name = XATTR_NAME_POSIX_ACL_DEFAULT; 47 47 break; 48 48 default: 49 49 return ERR_PTR(-EINVAL); ··· 82 82 83 83 switch (type) { 84 84 case ACL_TYPE_ACCESS: 85 - ea_name = POSIX_ACL_XATTR_ACCESS; 85 + ea_name = XATTR_NAME_POSIX_ACL_ACCESS; 86 86 if (acl) { 87 87 rc = posix_acl_equiv_mode(acl, &inode->i_mode); 88 88 if (rc < 0) ··· 94 94 } 95 95 break; 96 96 case ACL_TYPE_DEFAULT: 97 - ea_name = POSIX_ACL_XATTR_DEFAULT; 97 + ea_name = XATTR_NAME_POSIX_ACL_DEFAULT; 98 98 break; 99 99 default: 100 100 return -EINVAL;
+2 -2
fs/nfs/nfs3acl.c
··· 284 284 int error; 285 285 286 286 error = nfs3_list_one_acl(inode, ACL_TYPE_ACCESS, 287 - POSIX_ACL_XATTR_ACCESS, data, size, &result); 287 + XATTR_NAME_POSIX_ACL_ACCESS, data, size, &result); 288 288 if (error) 289 289 return error; 290 290 291 291 error = nfs3_list_one_acl(inode, ACL_TYPE_DEFAULT, 292 - POSIX_ACL_XATTR_DEFAULT, data, size, &result); 292 + XATTR_NAME_POSIX_ACL_DEFAULT, data, size, &result); 293 293 if (error) 294 294 return error; 295 295 return result;
+2 -2
fs/posix_acl.c
··· 845 845 } 846 846 847 847 const struct xattr_handler posix_acl_access_xattr_handler = { 848 - .prefix = POSIX_ACL_XATTR_ACCESS, 848 + .prefix = XATTR_NAME_POSIX_ACL_ACCESS, 849 849 .flags = ACL_TYPE_ACCESS, 850 850 .list = posix_acl_xattr_list, 851 851 .get = posix_acl_xattr_get, ··· 854 854 EXPORT_SYMBOL_GPL(posix_acl_access_xattr_handler); 855 855 856 856 const struct xattr_handler posix_acl_default_xattr_handler = { 857 - .prefix = POSIX_ACL_XATTR_DEFAULT, 857 + .prefix = XATTR_NAME_POSIX_ACL_DEFAULT, 858 858 .flags = ACL_TYPE_DEFAULT, 859 859 .list = posix_acl_xattr_list, 860 860 .get = posix_acl_xattr_get,
+4 -4
fs/reiserfs/xattr_acl.c
··· 186 186 187 187 switch (type) { 188 188 case ACL_TYPE_ACCESS: 189 - name = POSIX_ACL_XATTR_ACCESS; 189 + name = XATTR_NAME_POSIX_ACL_ACCESS; 190 190 break; 191 191 case ACL_TYPE_DEFAULT: 192 - name = POSIX_ACL_XATTR_DEFAULT; 192 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 193 193 break; 194 194 default: 195 195 BUG(); ··· 244 244 245 245 switch (type) { 246 246 case ACL_TYPE_ACCESS: 247 - name = POSIX_ACL_XATTR_ACCESS; 247 + name = XATTR_NAME_POSIX_ACL_ACCESS; 248 248 if (acl) { 249 249 error = posix_acl_equiv_mode(acl, &inode->i_mode); 250 250 if (error < 0) ··· 256 256 } 257 257 break; 258 258 case ACL_TYPE_DEFAULT: 259 - name = POSIX_ACL_XATTR_DEFAULT; 259 + name = XATTR_NAME_POSIX_ACL_DEFAULT; 260 260 if (!S_ISDIR(inode->i_mode)) 261 261 return acl ? -EACCES : 0; 262 262 break;
+4 -4
fs/xfs/xfs_xattr.c
··· 253 253 * Then add the two synthetic ACL attributes. 254 254 */ 255 255 if (posix_acl_access_exists(inode)) { 256 - error = list_one_attr(POSIX_ACL_XATTR_ACCESS, 257 - strlen(POSIX_ACL_XATTR_ACCESS) + 1, 256 + error = list_one_attr(XATTR_NAME_POSIX_ACL_ACCESS, 257 + strlen(XATTR_NAME_POSIX_ACL_ACCESS) + 1, 258 258 data, size, &context.count); 259 259 if (error) 260 260 return error; 261 261 } 262 262 263 263 if (posix_acl_default_exists(inode)) { 264 - error = list_one_attr(POSIX_ACL_XATTR_DEFAULT, 265 - strlen(POSIX_ACL_XATTR_DEFAULT) + 1, 264 + error = list_one_attr(XATTR_NAME_POSIX_ACL_DEFAULT, 265 + strlen(XATTR_NAME_POSIX_ACL_DEFAULT) + 1, 266 266 data, size, &context.count); 267 267 if (error) 268 268 return error;
+1 -5
include/linux/posix_acl_xattr.h
··· 9 9 #ifndef _POSIX_ACL_XATTR_H 10 10 #define _POSIX_ACL_XATTR_H 11 11 12 + #include <uapi/linux/xattr.h> 12 13 #include <linux/posix_acl.h> 13 - 14 - /* Extended attribute names */ 15 - #define POSIX_ACL_XATTR_ACCESS "system.posix_acl_access" 16 - #define POSIX_ACL_XATTR_DEFAULT "system.posix_acl_default" 17 14 18 15 /* Supported ACL a_version fields */ 19 16 #define POSIX_ACL_XATTR_VERSION 0x0002 20 - 21 17 22 18 /* An undefined entry e_id value */ 23 19 #define ACL_UNDEFINED_ID (-1)