]>
Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
f9e09f09 LM |
2 | /* |
3 | * Copyright (C) 2008 Christoph Hellwig. | |
4 | * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc. | |
f9e09f09 LM |
5 | */ |
6 | ||
7 | #include "xfs.h" | |
5467b34b | 8 | #include "xfs_shared.h" |
a4fbe6ab | 9 | #include "xfs_format.h" |
69432832 | 10 | #include "xfs_log_format.h" |
57062787 | 11 | #include "xfs_da_format.h" |
383e32b0 DW |
12 | #include "xfs_trans_resv.h" |
13 | #include "xfs_mount.h" | |
f9e09f09 | 14 | #include "xfs_inode.h" |
e0c41089 | 15 | #include "xfs_da_btree.h" |
f9e09f09 | 16 | #include "xfs_attr.h" |
5f213ddb | 17 | #include "xfs_acl.h" |
d9c61ccb DW |
18 | #include "xfs_log.h" |
19 | #include "xfs_xattr.h" | |
f9e09f09 LM |
20 | |
21 | #include <linux/posix_acl_xattr.h> | |
f9e09f09 | 22 | |
d9c61ccb DW |
23 | /* |
24 | * Get permission to use log-assisted atomic exchange of file extents. | |
25 | * | |
26 | * Callers must not be running any transactions or hold any inode locks, and | |
27 | * they must release the permission by calling xlog_drop_incompat_feat | |
28 | * when they're done. | |
29 | */ | |
efc2efeb | 30 | static inline int |
d9c61ccb DW |
31 | xfs_attr_grab_log_assist( |
32 | struct xfs_mount *mp) | |
33 | { | |
34 | int error = 0; | |
35 | ||
36 | /* | |
37 | * Protect ourselves from an idle log clearing the logged xattrs log | |
38 | * incompat feature bit. | |
39 | */ | |
40 | xlog_use_incompat_feat(mp->m_log); | |
41 | ||
42 | /* | |
43 | * If log-assisted xattrs are already enabled, the caller can use the | |
44 | * log assisted swap functions with the log-incompat reference we got. | |
45 | */ | |
46 | if (xfs_sb_version_haslogxattrs(&mp->m_sb)) | |
47 | return 0; | |
48 | ||
49 | /* Enable log-assisted xattrs. */ | |
50 | error = xfs_add_incompat_log_feature(mp, | |
51 | XFS_SB_FEAT_INCOMPAT_LOG_XATTRS); | |
52 | if (error) | |
53 | goto drop_incompat; | |
54 | ||
55 | xfs_warn_mount(mp, XFS_OPSTATE_WARNED_LARP, | |
56 | "EXPERIMENTAL logged extended attributes feature in use. Use at your own risk!"); | |
57 | ||
58 | return 0; | |
59 | drop_incompat: | |
60 | xlog_drop_incompat_feat(mp->m_log); | |
61 | return error; | |
62 | } | |
63 | ||
efc2efeb | 64 | static inline void |
d9c61ccb DW |
65 | xfs_attr_rele_log_assist( |
66 | struct xfs_mount *mp) | |
67 | { | |
68 | xlog_drop_incompat_feat(mp->m_log); | |
69 | } | |
f9e09f09 | 70 | |
f4288f01 DW |
71 | static inline bool |
72 | xfs_attr_want_log_assist( | |
73 | struct xfs_mount *mp) | |
74 | { | |
75 | #ifdef DEBUG | |
76 | /* Logged xattrs require a V5 super for log_incompat */ | |
77 | return xfs_has_crc(mp) && xfs_globals.larp; | |
78 | #else | |
79 | return false; | |
80 | #endif | |
81 | } | |
82 | ||
efc2efeb DW |
83 | /* |
84 | * Set or remove an xattr, having grabbed the appropriate logging resources | |
85 | * prior to calling libxfs. | |
86 | */ | |
87 | int | |
88 | xfs_attr_change( | |
89 | struct xfs_da_args *args) | |
90 | { | |
91 | struct xfs_mount *mp = args->dp->i_mount; | |
92 | bool use_logging = false; | |
93 | int error; | |
94 | ||
f4288f01 DW |
95 | ASSERT(!(args->op_flags & XFS_DA_OP_LOGGED)); |
96 | ||
97 | if (xfs_attr_want_log_assist(mp)) { | |
efc2efeb DW |
98 | error = xfs_attr_grab_log_assist(mp); |
99 | if (error) | |
100 | return error; | |
101 | ||
f4288f01 | 102 | args->op_flags |= XFS_DA_OP_LOGGED; |
efc2efeb DW |
103 | use_logging = true; |
104 | } | |
105 | ||
106 | error = xfs_attr_set(args); | |
107 | ||
108 | if (use_logging) | |
109 | xfs_attr_rele_log_assist(mp); | |
110 | return error; | |
111 | } | |
112 | ||
113 | ||
f9e09f09 | 114 | static int |
b296821a AV |
115 | xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused, |
116 | struct inode *inode, const char *name, void *value, size_t size) | |
f9e09f09 | 117 | { |
e5171d7e CH |
118 | struct xfs_da_args args = { |
119 | .dp = XFS_I(inode), | |
d5f0f49a | 120 | .attr_filter = handler->flags, |
e5171d7e CH |
121 | .name = name, |
122 | .namelen = strlen(name), | |
123 | .value = value, | |
124 | .valuelen = size, | |
125 | }; | |
126 | int error; | |
f9e09f09 | 127 | |
e5171d7e | 128 | error = xfs_attr_get(&args); |
f9e09f09 LM |
129 | if (error) |
130 | return error; | |
e5171d7e | 131 | return args.valuelen; |
f9e09f09 LM |
132 | } |
133 | ||
134 | static int | |
e65ce2a5 | 135 | xfs_xattr_set(const struct xattr_handler *handler, |
39f60c1c | 136 | struct mnt_idmap *idmap, struct dentry *unused, |
e65ce2a5 CB |
137 | struct inode *inode, const char *name, const void *value, |
138 | size_t size, int flags) | |
f9e09f09 | 139 | { |
a2544622 CH |
140 | struct xfs_da_args args = { |
141 | .dp = XFS_I(inode), | |
d5f0f49a CH |
142 | .attr_filter = handler->flags, |
143 | .attr_flags = flags, | |
a2544622 CH |
144 | .name = name, |
145 | .namelen = strlen(name), | |
146 | .value = (void *)value, | |
147 | .valuelen = size, | |
148 | }; | |
67d8e04e | 149 | int error; |
f9e09f09 | 150 | |
efc2efeb | 151 | error = xfs_attr_change(&args); |
d5f0f49a | 152 | if (!error && (handler->flags & XFS_ATTR_ROOT)) |
5a3930e2 | 153 | xfs_forget_acl(inode, name); |
67d8e04e | 154 | return error; |
f9e09f09 LM |
155 | } |
156 | ||
46e58764 | 157 | static const struct xattr_handler xfs_xattr_user_handler = { |
f9e09f09 | 158 | .prefix = XATTR_USER_PREFIX, |
431547b3 CH |
159 | .flags = 0, /* no flags implies user namespace */ |
160 | .get = xfs_xattr_get, | |
161 | .set = xfs_xattr_set, | |
f9e09f09 LM |
162 | }; |
163 | ||
46e58764 | 164 | static const struct xattr_handler xfs_xattr_trusted_handler = { |
f9e09f09 | 165 | .prefix = XATTR_TRUSTED_PREFIX, |
d5f0f49a | 166 | .flags = XFS_ATTR_ROOT, |
431547b3 CH |
167 | .get = xfs_xattr_get, |
168 | .set = xfs_xattr_set, | |
f9e09f09 LM |
169 | }; |
170 | ||
46e58764 | 171 | static const struct xattr_handler xfs_xattr_security_handler = { |
f9e09f09 | 172 | .prefix = XATTR_SECURITY_PREFIX, |
d5f0f49a | 173 | .flags = XFS_ATTR_SECURE, |
431547b3 CH |
174 | .get = xfs_xattr_get, |
175 | .set = xfs_xattr_set, | |
f9e09f09 LM |
176 | }; |
177 | ||
46e58764 | 178 | const struct xattr_handler *xfs_xattr_handlers[] = { |
f9e09f09 LM |
179 | &xfs_xattr_user_handler, |
180 | &xfs_xattr_trusted_handler, | |
181 | &xfs_xattr_security_handler, | |
ef14f0c1 | 182 | #ifdef CONFIG_XFS_POSIX_ACL |
2401dc29 CH |
183 | &posix_acl_access_xattr_handler, |
184 | &posix_acl_default_xattr_handler, | |
ef14f0c1 | 185 | #endif |
f9e09f09 LM |
186 | NULL |
187 | }; | |
188 | ||
f7a136ae | 189 | static void |
5d92b75c | 190 | __xfs_xattr_put_listent( |
a9273ca5 | 191 | struct xfs_attr_list_context *context, |
5d92b75c AG |
192 | char *prefix, |
193 | int prefix_len, | |
194 | unsigned char *name, | |
195 | int namelen) | |
f9e09f09 | 196 | { |
f9e09f09 LM |
197 | char *offset; |
198 | int arraytop; | |
199 | ||
3b50086f DW |
200 | if (context->count < 0 || context->seen_enough) |
201 | return; | |
202 | ||
a9c8c69b | 203 | if (!context->buffer) |
5d92b75c | 204 | goto compute_size; |
f9e09f09 LM |
205 | |
206 | arraytop = context->count + prefix_len + namelen + 1; | |
207 | if (arraytop > context->firstu) { | |
208 | context->count = -1; /* insufficient space */ | |
791cc43b | 209 | context->seen_enough = 1; |
f7a136ae | 210 | return; |
f9e09f09 | 211 | } |
a9c8c69b | 212 | offset = context->buffer + context->count; |
fd5beaff | 213 | memcpy(offset, prefix, prefix_len); |
f9e09f09 | 214 | offset += prefix_len; |
a9273ca5 | 215 | strncpy(offset, (char *)name, namelen); /* real name */ |
f9e09f09 LM |
216 | offset += namelen; |
217 | *offset = '\0'; | |
5d92b75c AG |
218 | |
219 | compute_size: | |
f9e09f09 | 220 | context->count += prefix_len + namelen + 1; |
f7a136ae | 221 | return; |
f9e09f09 LM |
222 | } |
223 | ||
f7a136ae | 224 | static void |
5d92b75c | 225 | xfs_xattr_put_listent( |
a9273ca5 DC |
226 | struct xfs_attr_list_context *context, |
227 | int flags, | |
228 | unsigned char *name, | |
229 | int namelen, | |
e5bd12bf | 230 | int valuelen) |
f9e09f09 | 231 | { |
5d92b75c AG |
232 | char *prefix; |
233 | int prefix_len; | |
f9e09f09 | 234 | |
5d92b75c | 235 | ASSERT(context->count >= 0); |
f9e09f09 | 236 | |
5d92b75c AG |
237 | if (flags & XFS_ATTR_ROOT) { |
238 | #ifdef CONFIG_XFS_POSIX_ACL | |
239 | if (namelen == SGI_ACL_FILE_SIZE && | |
240 | strncmp(name, SGI_ACL_FILE, | |
241 | SGI_ACL_FILE_SIZE) == 0) { | |
f7a136ae | 242 | __xfs_xattr_put_listent( |
5d92b75c AG |
243 | context, XATTR_SYSTEM_PREFIX, |
244 | XATTR_SYSTEM_PREFIX_LEN, | |
245 | XATTR_POSIX_ACL_ACCESS, | |
246 | strlen(XATTR_POSIX_ACL_ACCESS)); | |
5d92b75c AG |
247 | } else if (namelen == SGI_ACL_DEFAULT_SIZE && |
248 | strncmp(name, SGI_ACL_DEFAULT, | |
249 | SGI_ACL_DEFAULT_SIZE) == 0) { | |
f7a136ae | 250 | __xfs_xattr_put_listent( |
5d92b75c AG |
251 | context, XATTR_SYSTEM_PREFIX, |
252 | XATTR_SYSTEM_PREFIX_LEN, | |
253 | XATTR_POSIX_ACL_DEFAULT, | |
254 | strlen(XATTR_POSIX_ACL_DEFAULT)); | |
5d92b75c AG |
255 | } |
256 | #endif | |
f9e09f09 | 257 | |
5d92b75c AG |
258 | /* |
259 | * Only show root namespace entries if we are actually allowed to | |
260 | * see them. | |
261 | */ | |
262 | if (!capable(CAP_SYS_ADMIN)) | |
f7a136ae | 263 | return; |
5d92b75c AG |
264 | |
265 | prefix = XATTR_TRUSTED_PREFIX; | |
266 | prefix_len = XATTR_TRUSTED_PREFIX_LEN; | |
267 | } else if (flags & XFS_ATTR_SECURE) { | |
268 | prefix = XATTR_SECURITY_PREFIX; | |
269 | prefix_len = XATTR_SECURITY_PREFIX_LEN; | |
270 | } else { | |
271 | prefix = XATTR_USER_PREFIX; | |
272 | prefix_len = XATTR_USER_PREFIX_LEN; | |
273 | } | |
274 | ||
f7a136ae ES |
275 | __xfs_xattr_put_listent(context, prefix, prefix_len, name, |
276 | namelen); | |
277 | return; | |
f9e09f09 LM |
278 | } |
279 | ||
280 | ssize_t | |
2a6fba6d ES |
281 | xfs_vn_listxattr( |
282 | struct dentry *dentry, | |
283 | char *data, | |
284 | size_t size) | |
f9e09f09 LM |
285 | { |
286 | struct xfs_attr_list_context context; | |
2a6fba6d ES |
287 | struct inode *inode = d_inode(dentry); |
288 | int error; | |
f9e09f09 LM |
289 | |
290 | /* | |
291 | * First read the regular on-disk attributes. | |
292 | */ | |
293 | memset(&context, 0, sizeof(context)); | |
294 | context.dp = XFS_I(inode); | |
f9e09f09 | 295 | context.resynch = 1; |
a9c8c69b | 296 | context.buffer = size ? data : NULL; |
f9e09f09 LM |
297 | context.bufsize = size; |
298 | context.firstu = context.bufsize; | |
5d92b75c | 299 | context.put_listent = xfs_xattr_put_listent; |
f9e09f09 | 300 | |
17e1dd83 | 301 | error = xfs_attr_list(&context); |
2a6fba6d ES |
302 | if (error) |
303 | return error; | |
f9e09f09 LM |
304 | if (context.count < 0) |
305 | return -ERANGE; | |
306 | ||
f9e09f09 LM |
307 | return context.count; |
308 | } |