Loading...
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* Extended attribute handling for AFS. We use xattrs to get and set metadata
3 * instead of providing pioctl().
4 *
5 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
7 */
8
9#include <linux/slab.h>
10#include <linux/fs.h>
11#include <linux/xattr.h>
12#include "internal.h"
13
14/*
15 * Deal with the result of a successful fetch ACL operation.
16 */
17static void afs_acl_success(struct afs_operation *op)
18{
19 afs_vnode_commit_status(op, &op->file[0]);
20}
21
22static void afs_acl_put(struct afs_operation *op)
23{
24 kfree(op->acl);
25}
26
27static const struct afs_operation_ops afs_fetch_acl_operation = {
28 .issue_afs_rpc = afs_fs_fetch_acl,
29 .success = afs_acl_success,
30 .put = afs_acl_put,
31};
32
33/*
34 * Get a file's ACL.
35 */
36static int afs_xattr_get_acl(const struct xattr_handler *handler,
37 struct dentry *dentry,
38 struct inode *inode, const char *name,
39 void *buffer, size_t size)
40{
41 struct afs_operation *op;
42 struct afs_vnode *vnode = AFS_FS_I(inode);
43 struct afs_acl *acl = NULL;
44 int ret;
45
46 op = afs_alloc_operation(NULL, vnode->volume);
47 if (IS_ERR(op))
48 return -ENOMEM;
49
50 afs_op_set_vnode(op, 0, vnode);
51 op->ops = &afs_fetch_acl_operation;
52
53 afs_begin_vnode_operation(op);
54 afs_wait_for_operation(op);
55 acl = op->acl;
56 op->acl = NULL;
57 ret = afs_put_operation(op);
58
59 if (ret == 0) {
60 ret = acl->size;
61 if (size > 0) {
62 if (acl->size <= size)
63 memcpy(buffer, acl->data, acl->size);
64 else
65 ret = -ERANGE;
66 }
67 }
68
69 kfree(acl);
70 return ret;
71}
72
73static bool afs_make_acl(struct afs_operation *op,
74 const void *buffer, size_t size)
75{
76 struct afs_acl *acl;
77
78 acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL);
79 if (!acl) {
80 afs_op_nomem(op);
81 return false;
82 }
83
84 acl->size = size;
85 memcpy(acl->data, buffer, size);
86 op->acl = acl;
87 return true;
88}
89
90static const struct afs_operation_ops afs_store_acl_operation = {
91 .issue_afs_rpc = afs_fs_store_acl,
92 .success = afs_acl_success,
93 .put = afs_acl_put,
94};
95
96/*
97 * Set a file's AFS3 ACL.
98 */
99static int afs_xattr_set_acl(const struct xattr_handler *handler,
100 struct user_namespace *mnt_userns,
101 struct dentry *dentry,
102 struct inode *inode, const char *name,
103 const void *buffer, size_t size, int flags)
104{
105 struct afs_operation *op;
106 struct afs_vnode *vnode = AFS_FS_I(inode);
107
108 if (flags == XATTR_CREATE)
109 return -EINVAL;
110
111 op = afs_alloc_operation(NULL, vnode->volume);
112 if (IS_ERR(op))
113 return -ENOMEM;
114
115 afs_op_set_vnode(op, 0, vnode);
116 if (!afs_make_acl(op, buffer, size))
117 return afs_put_operation(op);
118
119 op->ops = &afs_store_acl_operation;
120 return afs_do_sync_operation(op);
121}
122
123static const struct xattr_handler afs_xattr_afs_acl_handler = {
124 .name = "afs.acl",
125 .get = afs_xattr_get_acl,
126 .set = afs_xattr_set_acl,
127};
128
129static const struct afs_operation_ops yfs_fetch_opaque_acl_operation = {
130 .issue_yfs_rpc = yfs_fs_fetch_opaque_acl,
131 .success = afs_acl_success,
132 /* Don't free op->yacl in .put here */
133};
134
135/*
136 * Get a file's YFS ACL.
137 */
138static int afs_xattr_get_yfs(const struct xattr_handler *handler,
139 struct dentry *dentry,
140 struct inode *inode, const char *name,
141 void *buffer, size_t size)
142{
143 struct afs_operation *op;
144 struct afs_vnode *vnode = AFS_FS_I(inode);
145 struct yfs_acl *yacl = NULL;
146 char buf[16], *data;
147 int which = 0, dsize, ret = -ENOMEM;
148
149 if (strcmp(name, "acl") == 0)
150 which = 0;
151 else if (strcmp(name, "acl_inherited") == 0)
152 which = 1;
153 else if (strcmp(name, "acl_num_cleaned") == 0)
154 which = 2;
155 else if (strcmp(name, "vol_acl") == 0)
156 which = 3;
157 else
158 return -EOPNOTSUPP;
159
160 yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL);
161 if (!yacl)
162 goto error;
163
164 if (which == 0)
165 yacl->flags |= YFS_ACL_WANT_ACL;
166 else if (which == 3)
167 yacl->flags |= YFS_ACL_WANT_VOL_ACL;
168
169 op = afs_alloc_operation(NULL, vnode->volume);
170 if (IS_ERR(op))
171 goto error_yacl;
172
173 afs_op_set_vnode(op, 0, vnode);
174 op->yacl = yacl;
175 op->ops = &yfs_fetch_opaque_acl_operation;
176
177 afs_begin_vnode_operation(op);
178 afs_wait_for_operation(op);
179 ret = afs_put_operation(op);
180
181 if (ret == 0) {
182 switch (which) {
183 case 0:
184 data = yacl->acl->data;
185 dsize = yacl->acl->size;
186 break;
187 case 1:
188 data = buf;
189 dsize = scnprintf(buf, sizeof(buf), "%u", yacl->inherit_flag);
190 break;
191 case 2:
192 data = buf;
193 dsize = scnprintf(buf, sizeof(buf), "%u", yacl->num_cleaned);
194 break;
195 case 3:
196 data = yacl->vol_acl->data;
197 dsize = yacl->vol_acl->size;
198 break;
199 default:
200 ret = -EOPNOTSUPP;
201 goto error_yacl;
202 }
203
204 ret = dsize;
205 if (size > 0) {
206 if (dsize <= size)
207 memcpy(buffer, data, dsize);
208 else
209 ret = -ERANGE;
210 }
211 } else if (ret == -ENOTSUPP) {
212 ret = -ENODATA;
213 }
214
215error_yacl:
216 yfs_free_opaque_acl(yacl);
217error:
218 return ret;
219}
220
221static const struct afs_operation_ops yfs_store_opaque_acl2_operation = {
222 .issue_yfs_rpc = yfs_fs_store_opaque_acl2,
223 .success = afs_acl_success,
224 .put = afs_acl_put,
225};
226
227/*
228 * Set a file's YFS ACL.
229 */
230static int afs_xattr_set_yfs(const struct xattr_handler *handler,
231 struct user_namespace *mnt_userns,
232 struct dentry *dentry,
233 struct inode *inode, const char *name,
234 const void *buffer, size_t size, int flags)
235{
236 struct afs_operation *op;
237 struct afs_vnode *vnode = AFS_FS_I(inode);
238 int ret;
239
240 if (flags == XATTR_CREATE ||
241 strcmp(name, "acl") != 0)
242 return -EINVAL;
243
244 op = afs_alloc_operation(NULL, vnode->volume);
245 if (IS_ERR(op))
246 return -ENOMEM;
247
248 afs_op_set_vnode(op, 0, vnode);
249 if (!afs_make_acl(op, buffer, size))
250 return afs_put_operation(op);
251
252 op->ops = &yfs_store_opaque_acl2_operation;
253 ret = afs_do_sync_operation(op);
254 if (ret == -ENOTSUPP)
255 ret = -ENODATA;
256 return ret;
257}
258
259static const struct xattr_handler afs_xattr_yfs_handler = {
260 .prefix = "afs.yfs.",
261 .get = afs_xattr_get_yfs,
262 .set = afs_xattr_set_yfs,
263};
264
265/*
266 * Get the name of the cell on which a file resides.
267 */
268static int afs_xattr_get_cell(const struct xattr_handler *handler,
269 struct dentry *dentry,
270 struct inode *inode, const char *name,
271 void *buffer, size_t size)
272{
273 struct afs_vnode *vnode = AFS_FS_I(inode);
274 struct afs_cell *cell = vnode->volume->cell;
275 size_t namelen;
276
277 namelen = cell->name_len;
278 if (size == 0)
279 return namelen;
280 if (namelen > size)
281 return -ERANGE;
282 memcpy(buffer, cell->name, namelen);
283 return namelen;
284}
285
286static const struct xattr_handler afs_xattr_afs_cell_handler = {
287 .name = "afs.cell",
288 .get = afs_xattr_get_cell,
289};
290
291/*
292 * Get the volume ID, vnode ID and vnode uniquifier of a file as a sequence of
293 * hex numbers separated by colons.
294 */
295static int afs_xattr_get_fid(const struct xattr_handler *handler,
296 struct dentry *dentry,
297 struct inode *inode, const char *name,
298 void *buffer, size_t size)
299{
300 struct afs_vnode *vnode = AFS_FS_I(inode);
301 char text[16 + 1 + 24 + 1 + 8 + 1];
302 size_t len;
303
304 /* The volume ID is 64-bit, the vnode ID is 96-bit and the
305 * uniquifier is 32-bit.
306 */
307 len = scnprintf(text, sizeof(text), "%llx:", vnode->fid.vid);
308 if (vnode->fid.vnode_hi)
309 len += scnprintf(text + len, sizeof(text) - len, "%x%016llx",
310 vnode->fid.vnode_hi, vnode->fid.vnode);
311 else
312 len += scnprintf(text + len, sizeof(text) - len, "%llx",
313 vnode->fid.vnode);
314 len += scnprintf(text + len, sizeof(text) - len, ":%x",
315 vnode->fid.unique);
316
317 if (size == 0)
318 return len;
319 if (len > size)
320 return -ERANGE;
321 memcpy(buffer, text, len);
322 return len;
323}
324
325static const struct xattr_handler afs_xattr_afs_fid_handler = {
326 .name = "afs.fid",
327 .get = afs_xattr_get_fid,
328};
329
330/*
331 * Get the name of the volume on which a file resides.
332 */
333static int afs_xattr_get_volume(const struct xattr_handler *handler,
334 struct dentry *dentry,
335 struct inode *inode, const char *name,
336 void *buffer, size_t size)
337{
338 struct afs_vnode *vnode = AFS_FS_I(inode);
339 const char *volname = vnode->volume->name;
340 size_t namelen;
341
342 namelen = strlen(volname);
343 if (size == 0)
344 return namelen;
345 if (namelen > size)
346 return -ERANGE;
347 memcpy(buffer, volname, namelen);
348 return namelen;
349}
350
351static const struct xattr_handler afs_xattr_afs_volume_handler = {
352 .name = "afs.volume",
353 .get = afs_xattr_get_volume,
354};
355
356const struct xattr_handler *afs_xattr_handlers[] = {
357 &afs_xattr_afs_acl_handler,
358 &afs_xattr_afs_cell_handler,
359 &afs_xattr_afs_fid_handler,
360 &afs_xattr_afs_volume_handler,
361 &afs_xattr_yfs_handler, /* afs.yfs. prefix */
362 NULL
363};
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* Extended attribute handling for AFS. We use xattrs to get and set metadata
3 * instead of providing pioctl().
4 *
5 * Copyright (C) 2017 Red Hat, Inc. All Rights Reserved.
6 * Written by David Howells (dhowells@redhat.com)
7 */
8
9#include <linux/slab.h>
10#include <linux/fs.h>
11#include <linux/xattr.h>
12#include "internal.h"
13
14static const char afs_xattr_list[] =
15 "afs.acl\0"
16 "afs.cell\0"
17 "afs.fid\0"
18 "afs.volume\0"
19 "afs.yfs.acl\0"
20 "afs.yfs.acl_inherited\0"
21 "afs.yfs.acl_num_cleaned\0"
22 "afs.yfs.vol_acl";
23
24/*
25 * Retrieve a list of the supported xattrs.
26 */
27ssize_t afs_listxattr(struct dentry *dentry, char *buffer, size_t size)
28{
29 if (size == 0)
30 return sizeof(afs_xattr_list);
31 if (size < sizeof(afs_xattr_list))
32 return -ERANGE;
33 memcpy(buffer, afs_xattr_list, sizeof(afs_xattr_list));
34 return sizeof(afs_xattr_list);
35}
36
37/*
38 * Get a file's ACL.
39 */
40static int afs_xattr_get_acl(const struct xattr_handler *handler,
41 struct dentry *dentry,
42 struct inode *inode, const char *name,
43 void *buffer, size_t size)
44{
45 struct afs_fs_cursor fc;
46 struct afs_status_cb *scb;
47 struct afs_vnode *vnode = AFS_FS_I(inode);
48 struct afs_acl *acl = NULL;
49 struct key *key;
50 int ret = -ENOMEM;
51
52 scb = kzalloc(sizeof(struct afs_status_cb), GFP_NOFS);
53 if (!scb)
54 goto error;
55
56 key = afs_request_key(vnode->volume->cell);
57 if (IS_ERR(key)) {
58 ret = PTR_ERR(key);
59 goto error_scb;
60 }
61
62 ret = -ERESTARTSYS;
63 if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
64 afs_dataversion_t data_version = vnode->status.data_version;
65
66 while (afs_select_fileserver(&fc)) {
67 fc.cb_break = afs_calc_vnode_cb_break(vnode);
68 acl = afs_fs_fetch_acl(&fc, scb);
69 }
70
71 afs_check_for_remote_deletion(&fc, fc.vnode);
72 afs_vnode_commit_status(&fc, vnode, fc.cb_break,
73 &data_version, scb);
74 ret = afs_end_vnode_operation(&fc);
75 }
76
77 if (ret == 0) {
78 ret = acl->size;
79 if (size > 0) {
80 if (acl->size <= size)
81 memcpy(buffer, acl->data, acl->size);
82 else
83 ret = -ERANGE;
84 }
85 kfree(acl);
86 }
87
88 key_put(key);
89error_scb:
90 kfree(scb);
91error:
92 return ret;
93}
94
95/*
96 * Set a file's AFS3 ACL.
97 */
98static int afs_xattr_set_acl(const struct xattr_handler *handler,
99 struct dentry *dentry,
100 struct inode *inode, const char *name,
101 const void *buffer, size_t size, int flags)
102{
103 struct afs_fs_cursor fc;
104 struct afs_status_cb *scb;
105 struct afs_vnode *vnode = AFS_FS_I(inode);
106 struct afs_acl *acl = NULL;
107 struct key *key;
108 int ret = -ENOMEM;
109
110 if (flags == XATTR_CREATE)
111 return -EINVAL;
112
113 scb = kzalloc(sizeof(struct afs_status_cb), GFP_NOFS);
114 if (!scb)
115 goto error;
116
117 acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL);
118 if (!acl)
119 goto error_scb;
120
121 key = afs_request_key(vnode->volume->cell);
122 if (IS_ERR(key)) {
123 ret = PTR_ERR(key);
124 goto error_acl;
125 }
126
127 acl->size = size;
128 memcpy(acl->data, buffer, size);
129
130 ret = -ERESTARTSYS;
131 if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
132 afs_dataversion_t data_version = vnode->status.data_version;
133
134 while (afs_select_fileserver(&fc)) {
135 fc.cb_break = afs_calc_vnode_cb_break(vnode);
136 afs_fs_store_acl(&fc, acl, scb);
137 }
138
139 afs_check_for_remote_deletion(&fc, fc.vnode);
140 afs_vnode_commit_status(&fc, vnode, fc.cb_break,
141 &data_version, scb);
142 ret = afs_end_vnode_operation(&fc);
143 }
144
145 key_put(key);
146error_acl:
147 kfree(acl);
148error_scb:
149 kfree(scb);
150error:
151 return ret;
152}
153
154static const struct xattr_handler afs_xattr_afs_acl_handler = {
155 .name = "afs.acl",
156 .get = afs_xattr_get_acl,
157 .set = afs_xattr_set_acl,
158};
159
160/*
161 * Get a file's YFS ACL.
162 */
163static int afs_xattr_get_yfs(const struct xattr_handler *handler,
164 struct dentry *dentry,
165 struct inode *inode, const char *name,
166 void *buffer, size_t size)
167{
168 struct afs_fs_cursor fc;
169 struct afs_status_cb *scb;
170 struct afs_vnode *vnode = AFS_FS_I(inode);
171 struct yfs_acl *yacl = NULL;
172 struct key *key;
173 char buf[16], *data;
174 int which = 0, dsize, ret = -ENOMEM;
175
176 if (strcmp(name, "acl") == 0)
177 which = 0;
178 else if (strcmp(name, "acl_inherited") == 0)
179 which = 1;
180 else if (strcmp(name, "acl_num_cleaned") == 0)
181 which = 2;
182 else if (strcmp(name, "vol_acl") == 0)
183 which = 3;
184 else
185 return -EOPNOTSUPP;
186
187 yacl = kzalloc(sizeof(struct yfs_acl), GFP_KERNEL);
188 if (!yacl)
189 goto error;
190
191 if (which == 0)
192 yacl->flags |= YFS_ACL_WANT_ACL;
193 else if (which == 3)
194 yacl->flags |= YFS_ACL_WANT_VOL_ACL;
195
196 scb = kzalloc(sizeof(struct afs_status_cb), GFP_NOFS);
197 if (!scb)
198 goto error_yacl;
199
200 key = afs_request_key(vnode->volume->cell);
201 if (IS_ERR(key)) {
202 ret = PTR_ERR(key);
203 goto error_scb;
204 }
205
206 ret = -ERESTARTSYS;
207 if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
208 afs_dataversion_t data_version = vnode->status.data_version;
209
210 while (afs_select_fileserver(&fc)) {
211 fc.cb_break = afs_calc_vnode_cb_break(vnode);
212 yfs_fs_fetch_opaque_acl(&fc, yacl, scb);
213 }
214
215 afs_check_for_remote_deletion(&fc, fc.vnode);
216 afs_vnode_commit_status(&fc, vnode, fc.cb_break,
217 &data_version, scb);
218 ret = afs_end_vnode_operation(&fc);
219 }
220
221 if (ret < 0)
222 goto error_key;
223
224 switch (which) {
225 case 0:
226 data = yacl->acl->data;
227 dsize = yacl->acl->size;
228 break;
229 case 1:
230 data = buf;
231 dsize = snprintf(buf, sizeof(buf), "%u", yacl->inherit_flag);
232 break;
233 case 2:
234 data = buf;
235 dsize = snprintf(buf, sizeof(buf), "%u", yacl->num_cleaned);
236 break;
237 case 3:
238 data = yacl->vol_acl->data;
239 dsize = yacl->vol_acl->size;
240 break;
241 default:
242 ret = -EOPNOTSUPP;
243 goto error_key;
244 }
245
246 ret = dsize;
247 if (size > 0) {
248 if (dsize > size) {
249 ret = -ERANGE;
250 goto error_key;
251 }
252 memcpy(buffer, data, dsize);
253 }
254
255error_key:
256 key_put(key);
257error_scb:
258 kfree(scb);
259error_yacl:
260 yfs_free_opaque_acl(yacl);
261error:
262 return ret;
263}
264
265/*
266 * Set a file's YFS ACL.
267 */
268static int afs_xattr_set_yfs(const struct xattr_handler *handler,
269 struct dentry *dentry,
270 struct inode *inode, const char *name,
271 const void *buffer, size_t size, int flags)
272{
273 struct afs_fs_cursor fc;
274 struct afs_status_cb *scb;
275 struct afs_vnode *vnode = AFS_FS_I(inode);
276 struct afs_acl *acl = NULL;
277 struct key *key;
278 int ret = -ENOMEM;
279
280 if (flags == XATTR_CREATE ||
281 strcmp(name, "acl") != 0)
282 return -EINVAL;
283
284 scb = kzalloc(sizeof(struct afs_status_cb), GFP_NOFS);
285 if (!scb)
286 goto error;
287
288 acl = kmalloc(sizeof(*acl) + size, GFP_KERNEL);
289 if (!acl)
290 goto error_scb;
291
292 acl->size = size;
293 memcpy(acl->data, buffer, size);
294
295 key = afs_request_key(vnode->volume->cell);
296 if (IS_ERR(key)) {
297 ret = PTR_ERR(key);
298 goto error_acl;
299 }
300
301 ret = -ERESTARTSYS;
302 if (afs_begin_vnode_operation(&fc, vnode, key, true)) {
303 afs_dataversion_t data_version = vnode->status.data_version;
304
305 while (afs_select_fileserver(&fc)) {
306 fc.cb_break = afs_calc_vnode_cb_break(vnode);
307 yfs_fs_store_opaque_acl2(&fc, acl, scb);
308 }
309
310 afs_check_for_remote_deletion(&fc, fc.vnode);
311 afs_vnode_commit_status(&fc, vnode, fc.cb_break,
312 &data_version, scb);
313 ret = afs_end_vnode_operation(&fc);
314 }
315
316error_acl:
317 kfree(acl);
318 key_put(key);
319error_scb:
320 kfree(scb);
321error:
322 return ret;
323}
324
325static const struct xattr_handler afs_xattr_yfs_handler = {
326 .prefix = "afs.yfs.",
327 .get = afs_xattr_get_yfs,
328 .set = afs_xattr_set_yfs,
329};
330
331/*
332 * Get the name of the cell on which a file resides.
333 */
334static int afs_xattr_get_cell(const struct xattr_handler *handler,
335 struct dentry *dentry,
336 struct inode *inode, const char *name,
337 void *buffer, size_t size)
338{
339 struct afs_vnode *vnode = AFS_FS_I(inode);
340 struct afs_cell *cell = vnode->volume->cell;
341 size_t namelen;
342
343 namelen = cell->name_len;
344 if (size == 0)
345 return namelen;
346 if (namelen > size)
347 return -ERANGE;
348 memcpy(buffer, cell->name, namelen);
349 return namelen;
350}
351
352static const struct xattr_handler afs_xattr_afs_cell_handler = {
353 .name = "afs.cell",
354 .get = afs_xattr_get_cell,
355};
356
357/*
358 * Get the volume ID, vnode ID and vnode uniquifier of a file as a sequence of
359 * hex numbers separated by colons.
360 */
361static int afs_xattr_get_fid(const struct xattr_handler *handler,
362 struct dentry *dentry,
363 struct inode *inode, const char *name,
364 void *buffer, size_t size)
365{
366 struct afs_vnode *vnode = AFS_FS_I(inode);
367 char text[16 + 1 + 24 + 1 + 8 + 1];
368 size_t len;
369
370 /* The volume ID is 64-bit, the vnode ID is 96-bit and the
371 * uniquifier is 32-bit.
372 */
373 len = sprintf(text, "%llx:", vnode->fid.vid);
374 if (vnode->fid.vnode_hi)
375 len += sprintf(text + len, "%x%016llx",
376 vnode->fid.vnode_hi, vnode->fid.vnode);
377 else
378 len += sprintf(text + len, "%llx", vnode->fid.vnode);
379 len += sprintf(text + len, ":%x", vnode->fid.unique);
380
381 if (size == 0)
382 return len;
383 if (len > size)
384 return -ERANGE;
385 memcpy(buffer, text, len);
386 return len;
387}
388
389static const struct xattr_handler afs_xattr_afs_fid_handler = {
390 .name = "afs.fid",
391 .get = afs_xattr_get_fid,
392};
393
394/*
395 * Get the name of the volume on which a file resides.
396 */
397static int afs_xattr_get_volume(const struct xattr_handler *handler,
398 struct dentry *dentry,
399 struct inode *inode, const char *name,
400 void *buffer, size_t size)
401{
402 struct afs_vnode *vnode = AFS_FS_I(inode);
403 const char *volname = vnode->volume->name;
404 size_t namelen;
405
406 namelen = strlen(volname);
407 if (size == 0)
408 return namelen;
409 if (namelen > size)
410 return -ERANGE;
411 memcpy(buffer, volname, namelen);
412 return namelen;
413}
414
415static const struct xattr_handler afs_xattr_afs_volume_handler = {
416 .name = "afs.volume",
417 .get = afs_xattr_get_volume,
418};
419
420const struct xattr_handler *afs_xattr_handlers[] = {
421 &afs_xattr_afs_acl_handler,
422 &afs_xattr_afs_cell_handler,
423 &afs_xattr_afs_fid_handler,
424 &afs_xattr_afs_volume_handler,
425 &afs_xattr_yfs_handler, /* afs.yfs. prefix */
426 NULL
427};