diff options
Diffstat (limited to 'fs/gfs2/xattr.c')
-rw-r--r-- | fs/gfs2/xattr.c | 1558 |
1 files changed, 1558 insertions, 0 deletions
diff --git a/fs/gfs2/xattr.c b/fs/gfs2/xattr.c new file mode 100644 index 000000000000..34ae9ba4c9fe --- /dev/null +++ b/fs/gfs2/xattr.c | |||
@@ -0,0 +1,1558 @@ | |||
1 | /* | ||
2 | * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. | ||
3 | * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. | ||
4 | * | ||
5 | * This copyrighted material is made available to anyone wishing to use, | ||
6 | * modify, copy, or redistribute it subject to the terms and conditions | ||
7 | * of the GNU General Public License version 2. | ||
8 | */ | ||
9 | |||
10 | #include <linux/slab.h> | ||
11 | #include <linux/spinlock.h> | ||
12 | #include <linux/completion.h> | ||
13 | #include <linux/buffer_head.h> | ||
14 | #include <linux/xattr.h> | ||
15 | #include <linux/gfs2_ondisk.h> | ||
16 | #include <asm/uaccess.h> | ||
17 | |||
18 | #include "gfs2.h" | ||
19 | #include "incore.h" | ||
20 | #include "acl.h" | ||
21 | #include "xattr.h" | ||
22 | #include "glock.h" | ||
23 | #include "inode.h" | ||
24 | #include "meta_io.h" | ||
25 | #include "quota.h" | ||
26 | #include "rgrp.h" | ||
27 | #include "trans.h" | ||
28 | #include "util.h" | ||
29 | |||
30 | /** | ||
31 | * ea_calc_size - returns the acutal number of bytes the request will take up | ||
32 | * (not counting any unstuffed data blocks) | ||
33 | * @sdp: | ||
34 | * @er: | ||
35 | * @size: | ||
36 | * | ||
37 | * Returns: 1 if the EA should be stuffed | ||
38 | */ | ||
39 | |||
40 | static int ea_calc_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize, | ||
41 | unsigned int *size) | ||
42 | { | ||
43 | unsigned int jbsize = sdp->sd_jbsize; | ||
44 | |||
45 | /* Stuffed */ | ||
46 | *size = ALIGN(sizeof(struct gfs2_ea_header) + nsize + dsize, 8); | ||
47 | |||
48 | if (*size <= jbsize) | ||
49 | return 1; | ||
50 | |||
51 | /* Unstuffed */ | ||
52 | *size = ALIGN(sizeof(struct gfs2_ea_header) + nsize + | ||
53 | (sizeof(__be64) * DIV_ROUND_UP(dsize, jbsize)), 8); | ||
54 | |||
55 | return 0; | ||
56 | } | ||
57 | |||
58 | static int ea_check_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize) | ||
59 | { | ||
60 | unsigned int size; | ||
61 | |||
62 | if (dsize > GFS2_EA_MAX_DATA_LEN) | ||
63 | return -ERANGE; | ||
64 | |||
65 | ea_calc_size(sdp, nsize, dsize, &size); | ||
66 | |||
67 | /* This can only happen with 512 byte blocks */ | ||
68 | if (size > sdp->sd_jbsize) | ||
69 | return -ERANGE; | ||
70 | |||
71 | return 0; | ||
72 | } | ||
73 | |||
74 | typedef int (*ea_call_t) (struct gfs2_inode *ip, struct buffer_head *bh, | ||
75 | struct gfs2_ea_header *ea, | ||
76 | struct gfs2_ea_header *prev, void *private); | ||
77 | |||
78 | static int ea_foreach_i(struct gfs2_inode *ip, struct buffer_head *bh, | ||
79 | ea_call_t ea_call, void *data) | ||
80 | { | ||
81 | struct gfs2_ea_header *ea, *prev = NULL; | ||
82 | int error = 0; | ||
83 | |||
84 | if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA)) | ||
85 | return -EIO; | ||
86 | |||
87 | for (ea = GFS2_EA_BH2FIRST(bh);; prev = ea, ea = GFS2_EA2NEXT(ea)) { | ||
88 | if (!GFS2_EA_REC_LEN(ea)) | ||
89 | goto fail; | ||
90 | if (!(bh->b_data <= (char *)ea && (char *)GFS2_EA2NEXT(ea) <= | ||
91 | bh->b_data + bh->b_size)) | ||
92 | goto fail; | ||
93 | if (!GFS2_EATYPE_VALID(ea->ea_type)) | ||
94 | goto fail; | ||
95 | |||
96 | error = ea_call(ip, bh, ea, prev, data); | ||
97 | if (error) | ||
98 | return error; | ||
99 | |||
100 | if (GFS2_EA_IS_LAST(ea)) { | ||
101 | if ((char *)GFS2_EA2NEXT(ea) != | ||
102 | bh->b_data + bh->b_size) | ||
103 | goto fail; | ||
104 | break; | ||
105 | } | ||
106 | } | ||
107 | |||
108 | return error; | ||
109 | |||
110 | fail: | ||
111 | gfs2_consist_inode(ip); | ||
112 | return -EIO; | ||
113 | } | ||
114 | |||
115 | static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data) | ||
116 | { | ||
117 | struct buffer_head *bh, *eabh; | ||
118 | __be64 *eablk, *end; | ||
119 | int error; | ||
120 | |||
121 | error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh); | ||
122 | if (error) | ||
123 | return error; | ||
124 | |||
125 | if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) { | ||
126 | error = ea_foreach_i(ip, bh, ea_call, data); | ||
127 | goto out; | ||
128 | } | ||
129 | |||
130 | if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) { | ||
131 | error = -EIO; | ||
132 | goto out; | ||
133 | } | ||
134 | |||
135 | eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header)); | ||
136 | end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs; | ||
137 | |||
138 | for (; eablk < end; eablk++) { | ||
139 | u64 bn; | ||
140 | |||
141 | if (!*eablk) | ||
142 | break; | ||
143 | bn = be64_to_cpu(*eablk); | ||
144 | |||
145 | error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh); | ||
146 | if (error) | ||
147 | break; | ||
148 | error = ea_foreach_i(ip, eabh, ea_call, data); | ||
149 | brelse(eabh); | ||
150 | if (error) | ||
151 | break; | ||
152 | } | ||
153 | out: | ||
154 | brelse(bh); | ||
155 | return error; | ||
156 | } | ||
157 | |||
158 | struct ea_find { | ||
159 | int type; | ||
160 | const char *name; | ||
161 | size_t namel; | ||
162 | struct gfs2_ea_location *ef_el; | ||
163 | }; | ||
164 | |||
165 | static int ea_find_i(struct gfs2_inode *ip, struct buffer_head *bh, | ||
166 | struct gfs2_ea_header *ea, struct gfs2_ea_header *prev, | ||
167 | void *private) | ||
168 | { | ||
169 | struct ea_find *ef = private; | ||
170 | |||
171 | if (ea->ea_type == GFS2_EATYPE_UNUSED) | ||
172 | return 0; | ||
173 | |||
174 | if (ea->ea_type == ef->type) { | ||
175 | if (ea->ea_name_len == ef->namel && | ||
176 | !memcmp(GFS2_EA2NAME(ea), ef->name, ea->ea_name_len)) { | ||
177 | struct gfs2_ea_location *el = ef->ef_el; | ||
178 | get_bh(bh); | ||
179 | el->el_bh = bh; | ||
180 | el->el_ea = ea; | ||
181 | el->el_prev = prev; | ||
182 | return 1; | ||
183 | } | ||
184 | } | ||
185 | |||
186 | return 0; | ||
187 | } | ||
188 | |||
189 | int gfs2_ea_find(struct gfs2_inode *ip, int type, const char *name, | ||
190 | struct gfs2_ea_location *el) | ||
191 | { | ||
192 | struct ea_find ef; | ||
193 | int error; | ||
194 | |||
195 | ef.type = type; | ||
196 | ef.name = name; | ||
197 | ef.namel = strlen(name); | ||
198 | ef.ef_el = el; | ||
199 | |||
200 | memset(el, 0, sizeof(struct gfs2_ea_location)); | ||
201 | |||
202 | error = ea_foreach(ip, ea_find_i, &ef); | ||
203 | if (error > 0) | ||
204 | return 0; | ||
205 | |||
206 | return error; | ||
207 | } | ||
208 | |||
209 | /** | ||
210 | * ea_dealloc_unstuffed - | ||
211 | * @ip: | ||
212 | * @bh: | ||
213 | * @ea: | ||
214 | * @prev: | ||
215 | * @private: | ||
216 | * | ||
217 | * Take advantage of the fact that all unstuffed blocks are | ||
218 | * allocated from the same RG. But watch, this may not always | ||
219 | * be true. | ||
220 | * | ||
221 | * Returns: errno | ||
222 | */ | ||
223 | |||
224 | static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh, | ||
225 | struct gfs2_ea_header *ea, | ||
226 | struct gfs2_ea_header *prev, void *private) | ||
227 | { | ||
228 | int *leave = private; | ||
229 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
230 | struct gfs2_rgrpd *rgd; | ||
231 | struct gfs2_holder rg_gh; | ||
232 | struct buffer_head *dibh; | ||
233 | __be64 *dataptrs; | ||
234 | u64 bn = 0; | ||
235 | u64 bstart = 0; | ||
236 | unsigned int blen = 0; | ||
237 | unsigned int blks = 0; | ||
238 | unsigned int x; | ||
239 | int error; | ||
240 | |||
241 | if (GFS2_EA_IS_STUFFED(ea)) | ||
242 | return 0; | ||
243 | |||
244 | dataptrs = GFS2_EA2DATAPTRS(ea); | ||
245 | for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) { | ||
246 | if (*dataptrs) { | ||
247 | blks++; | ||
248 | bn = be64_to_cpu(*dataptrs); | ||
249 | } | ||
250 | } | ||
251 | if (!blks) | ||
252 | return 0; | ||
253 | |||
254 | rgd = gfs2_blk2rgrpd(sdp, bn); | ||
255 | if (!rgd) { | ||
256 | gfs2_consist_inode(ip); | ||
257 | return -EIO; | ||
258 | } | ||
259 | |||
260 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh); | ||
261 | if (error) | ||
262 | return error; | ||
263 | |||
264 | error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE + | ||
265 | RES_EATTR + RES_STATFS + RES_QUOTA, blks); | ||
266 | if (error) | ||
267 | goto out_gunlock; | ||
268 | |||
269 | gfs2_trans_add_bh(ip->i_gl, bh, 1); | ||
270 | |||
271 | dataptrs = GFS2_EA2DATAPTRS(ea); | ||
272 | for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) { | ||
273 | if (!*dataptrs) | ||
274 | break; | ||
275 | bn = be64_to_cpu(*dataptrs); | ||
276 | |||
277 | if (bstart + blen == bn) | ||
278 | blen++; | ||
279 | else { | ||
280 | if (bstart) | ||
281 | gfs2_free_meta(ip, bstart, blen); | ||
282 | bstart = bn; | ||
283 | blen = 1; | ||
284 | } | ||
285 | |||
286 | *dataptrs = 0; | ||
287 | gfs2_add_inode_blocks(&ip->i_inode, -1); | ||
288 | } | ||
289 | if (bstart) | ||
290 | gfs2_free_meta(ip, bstart, blen); | ||
291 | |||
292 | if (prev && !leave) { | ||
293 | u32 len; | ||
294 | |||
295 | len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea); | ||
296 | prev->ea_rec_len = cpu_to_be32(len); | ||
297 | |||
298 | if (GFS2_EA_IS_LAST(ea)) | ||
299 | prev->ea_flags |= GFS2_EAFLAG_LAST; | ||
300 | } else { | ||
301 | ea->ea_type = GFS2_EATYPE_UNUSED; | ||
302 | ea->ea_num_ptrs = 0; | ||
303 | } | ||
304 | |||
305 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
306 | if (!error) { | ||
307 | ip->i_inode.i_ctime = CURRENT_TIME; | ||
308 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
309 | gfs2_dinode_out(ip, dibh->b_data); | ||
310 | brelse(dibh); | ||
311 | } | ||
312 | |||
313 | gfs2_trans_end(sdp); | ||
314 | |||
315 | out_gunlock: | ||
316 | gfs2_glock_dq_uninit(&rg_gh); | ||
317 | return error; | ||
318 | } | ||
319 | |||
320 | static int ea_remove_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh, | ||
321 | struct gfs2_ea_header *ea, | ||
322 | struct gfs2_ea_header *prev, int leave) | ||
323 | { | ||
324 | struct gfs2_alloc *al; | ||
325 | int error; | ||
326 | |||
327 | al = gfs2_alloc_get(ip); | ||
328 | if (!al) | ||
329 | return -ENOMEM; | ||
330 | |||
331 | error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); | ||
332 | if (error) | ||
333 | goto out_alloc; | ||
334 | |||
335 | error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh); | ||
336 | if (error) | ||
337 | goto out_quota; | ||
338 | |||
339 | error = ea_dealloc_unstuffed(ip, bh, ea, prev, (leave) ? &error : NULL); | ||
340 | |||
341 | gfs2_glock_dq_uninit(&al->al_ri_gh); | ||
342 | |||
343 | out_quota: | ||
344 | gfs2_quota_unhold(ip); | ||
345 | out_alloc: | ||
346 | gfs2_alloc_put(ip); | ||
347 | return error; | ||
348 | } | ||
349 | |||
350 | struct ea_list { | ||
351 | struct gfs2_ea_request *ei_er; | ||
352 | unsigned int ei_size; | ||
353 | }; | ||
354 | |||
355 | static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header *ea) | ||
356 | { | ||
357 | switch (ea->ea_type) { | ||
358 | case GFS2_EATYPE_USR: | ||
359 | return 5 + ea->ea_name_len + 1; | ||
360 | case GFS2_EATYPE_SYS: | ||
361 | return 7 + ea->ea_name_len + 1; | ||
362 | case GFS2_EATYPE_SECURITY: | ||
363 | return 9 + ea->ea_name_len + 1; | ||
364 | default: | ||
365 | return 0; | ||
366 | } | ||
367 | } | ||
368 | |||
369 | static int ea_list_i(struct gfs2_inode *ip, struct buffer_head *bh, | ||
370 | struct gfs2_ea_header *ea, struct gfs2_ea_header *prev, | ||
371 | void *private) | ||
372 | { | ||
373 | struct ea_list *ei = private; | ||
374 | struct gfs2_ea_request *er = ei->ei_er; | ||
375 | unsigned int ea_size = gfs2_ea_strlen(ea); | ||
376 | |||
377 | if (ea->ea_type == GFS2_EATYPE_UNUSED) | ||
378 | return 0; | ||
379 | |||
380 | if (er->er_data_len) { | ||
381 | char *prefix = NULL; | ||
382 | unsigned int l = 0; | ||
383 | char c = 0; | ||
384 | |||
385 | if (ei->ei_size + ea_size > er->er_data_len) | ||
386 | return -ERANGE; | ||
387 | |||
388 | switch (ea->ea_type) { | ||
389 | case GFS2_EATYPE_USR: | ||
390 | prefix = "user."; | ||
391 | l = 5; | ||
392 | break; | ||
393 | case GFS2_EATYPE_SYS: | ||
394 | prefix = "system."; | ||
395 | l = 7; | ||
396 | break; | ||
397 | case GFS2_EATYPE_SECURITY: | ||
398 | prefix = "security."; | ||
399 | l = 9; | ||
400 | break; | ||
401 | } | ||
402 | |||
403 | BUG_ON(l == 0); | ||
404 | |||
405 | memcpy(er->er_data + ei->ei_size, prefix, l); | ||
406 | memcpy(er->er_data + ei->ei_size + l, GFS2_EA2NAME(ea), | ||
407 | ea->ea_name_len); | ||
408 | memcpy(er->er_data + ei->ei_size + ea_size - 1, &c, 1); | ||
409 | } | ||
410 | |||
411 | ei->ei_size += ea_size; | ||
412 | |||
413 | return 0; | ||
414 | } | ||
415 | |||
416 | /** | ||
417 | * gfs2_listxattr - List gfs2 extended attributes | ||
418 | * @dentry: The dentry whose inode we are interested in | ||
419 | * @buffer: The buffer to write the results | ||
420 | * @size: The size of the buffer | ||
421 | * | ||
422 | * Returns: actual size of data on success, -errno on error | ||
423 | */ | ||
424 | |||
425 | ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size) | ||
426 | { | ||
427 | struct gfs2_inode *ip = GFS2_I(dentry->d_inode); | ||
428 | struct gfs2_ea_request er; | ||
429 | struct gfs2_holder i_gh; | ||
430 | int error; | ||
431 | |||
432 | memset(&er, 0, sizeof(struct gfs2_ea_request)); | ||
433 | if (size) { | ||
434 | er.er_data = buffer; | ||
435 | er.er_data_len = size; | ||
436 | } | ||
437 | |||
438 | error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); | ||
439 | if (error) | ||
440 | return error; | ||
441 | |||
442 | if (ip->i_eattr) { | ||
443 | struct ea_list ei = { .ei_er = &er, .ei_size = 0 }; | ||
444 | |||
445 | error = ea_foreach(ip, ea_list_i, &ei); | ||
446 | if (!error) | ||
447 | error = ei.ei_size; | ||
448 | } | ||
449 | |||
450 | gfs2_glock_dq_uninit(&i_gh); | ||
451 | |||
452 | return error; | ||
453 | } | ||
454 | |||
455 | /** | ||
456 | * ea_get_unstuffed - actually copies the unstuffed data into the | ||
457 | * request buffer | ||
458 | * @ip: The GFS2 inode | ||
459 | * @ea: The extended attribute header structure | ||
460 | * @data: The data to be copied | ||
461 | * | ||
462 | * Returns: errno | ||
463 | */ | ||
464 | |||
465 | static int ea_get_unstuffed(struct gfs2_inode *ip, struct gfs2_ea_header *ea, | ||
466 | char *data) | ||
467 | { | ||
468 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
469 | struct buffer_head **bh; | ||
470 | unsigned int amount = GFS2_EA_DATA_LEN(ea); | ||
471 | unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize); | ||
472 | __be64 *dataptrs = GFS2_EA2DATAPTRS(ea); | ||
473 | unsigned int x; | ||
474 | int error = 0; | ||
475 | |||
476 | bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS); | ||
477 | if (!bh) | ||
478 | return -ENOMEM; | ||
479 | |||
480 | for (x = 0; x < nptrs; x++) { | ||
481 | error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0, | ||
482 | bh + x); | ||
483 | if (error) { | ||
484 | while (x--) | ||
485 | brelse(bh[x]); | ||
486 | goto out; | ||
487 | } | ||
488 | dataptrs++; | ||
489 | } | ||
490 | |||
491 | for (x = 0; x < nptrs; x++) { | ||
492 | error = gfs2_meta_wait(sdp, bh[x]); | ||
493 | if (error) { | ||
494 | for (; x < nptrs; x++) | ||
495 | brelse(bh[x]); | ||
496 | goto out; | ||
497 | } | ||
498 | if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) { | ||
499 | for (; x < nptrs; x++) | ||
500 | brelse(bh[x]); | ||
501 | error = -EIO; | ||
502 | goto out; | ||
503 | } | ||
504 | |||
505 | memcpy(data, bh[x]->b_data + sizeof(struct gfs2_meta_header), | ||
506 | (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize); | ||
507 | |||
508 | amount -= sdp->sd_jbsize; | ||
509 | data += sdp->sd_jbsize; | ||
510 | |||
511 | brelse(bh[x]); | ||
512 | } | ||
513 | |||
514 | out: | ||
515 | kfree(bh); | ||
516 | return error; | ||
517 | } | ||
518 | |||
519 | int gfs2_ea_get_copy(struct gfs2_inode *ip, struct gfs2_ea_location *el, | ||
520 | char *data, size_t size) | ||
521 | { | ||
522 | int ret; | ||
523 | size_t len = GFS2_EA_DATA_LEN(el->el_ea); | ||
524 | if (len > size) | ||
525 | return -ERANGE; | ||
526 | |||
527 | if (GFS2_EA_IS_STUFFED(el->el_ea)) { | ||
528 | memcpy(data, GFS2_EA2DATA(el->el_ea), len); | ||
529 | return len; | ||
530 | } | ||
531 | ret = ea_get_unstuffed(ip, el->el_ea, data); | ||
532 | if (ret < 0) | ||
533 | return ret; | ||
534 | return len; | ||
535 | } | ||
536 | |||
537 | /** | ||
538 | * gfs2_xattr_get - Get a GFS2 extended attribute | ||
539 | * @inode: The inode | ||
540 | * @type: The type of extended attribute | ||
541 | * @name: The name of the extended attribute | ||
542 | * @buffer: The buffer to write the result into | ||
543 | * @size: The size of the buffer | ||
544 | * | ||
545 | * Returns: actual size of data on success, -errno on error | ||
546 | */ | ||
547 | |||
548 | int gfs2_xattr_get(struct inode *inode, int type, const char *name, | ||
549 | void *buffer, size_t size) | ||
550 | { | ||
551 | struct gfs2_inode *ip = GFS2_I(inode); | ||
552 | struct gfs2_ea_location el; | ||
553 | int error; | ||
554 | |||
555 | if (!ip->i_eattr) | ||
556 | return -ENODATA; | ||
557 | if (strlen(name) > GFS2_EA_MAX_NAME_LEN) | ||
558 | return -EINVAL; | ||
559 | |||
560 | error = gfs2_ea_find(ip, type, name, &el); | ||
561 | if (error) | ||
562 | return error; | ||
563 | if (!el.el_ea) | ||
564 | return -ENODATA; | ||
565 | if (size) | ||
566 | error = gfs2_ea_get_copy(ip, &el, buffer, size); | ||
567 | else | ||
568 | error = GFS2_EA_DATA_LEN(el.el_ea); | ||
569 | brelse(el.el_bh); | ||
570 | |||
571 | return error; | ||
572 | } | ||
573 | |||
574 | /** | ||
575 | * ea_alloc_blk - allocates a new block for extended attributes. | ||
576 | * @ip: A pointer to the inode that's getting extended attributes | ||
577 | * @bhp: Pointer to pointer to a struct buffer_head | ||
578 | * | ||
579 | * Returns: errno | ||
580 | */ | ||
581 | |||
582 | static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp) | ||
583 | { | ||
584 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
585 | struct gfs2_ea_header *ea; | ||
586 | unsigned int n = 1; | ||
587 | u64 block; | ||
588 | int error; | ||
589 | |||
590 | error = gfs2_alloc_block(ip, &block, &n); | ||
591 | if (error) | ||
592 | return error; | ||
593 | gfs2_trans_add_unrevoke(sdp, block, 1); | ||
594 | *bhp = gfs2_meta_new(ip->i_gl, block); | ||
595 | gfs2_trans_add_bh(ip->i_gl, *bhp, 1); | ||
596 | gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA); | ||
597 | gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header)); | ||
598 | |||
599 | ea = GFS2_EA_BH2FIRST(*bhp); | ||
600 | ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize); | ||
601 | ea->ea_type = GFS2_EATYPE_UNUSED; | ||
602 | ea->ea_flags = GFS2_EAFLAG_LAST; | ||
603 | ea->ea_num_ptrs = 0; | ||
604 | |||
605 | gfs2_add_inode_blocks(&ip->i_inode, 1); | ||
606 | |||
607 | return 0; | ||
608 | } | ||
609 | |||
610 | /** | ||
611 | * ea_write - writes the request info to an ea, creating new blocks if | ||
612 | * necessary | ||
613 | * @ip: inode that is being modified | ||
614 | * @ea: the location of the new ea in a block | ||
615 | * @er: the write request | ||
616 | * | ||
617 | * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags | ||
618 | * | ||
619 | * returns : errno | ||
620 | */ | ||
621 | |||
622 | static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea, | ||
623 | struct gfs2_ea_request *er) | ||
624 | { | ||
625 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
626 | int error; | ||
627 | |||
628 | ea->ea_data_len = cpu_to_be32(er->er_data_len); | ||
629 | ea->ea_name_len = er->er_name_len; | ||
630 | ea->ea_type = er->er_type; | ||
631 | ea->__pad = 0; | ||
632 | |||
633 | memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len); | ||
634 | |||
635 | if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) { | ||
636 | ea->ea_num_ptrs = 0; | ||
637 | memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len); | ||
638 | } else { | ||
639 | __be64 *dataptr = GFS2_EA2DATAPTRS(ea); | ||
640 | const char *data = er->er_data; | ||
641 | unsigned int data_len = er->er_data_len; | ||
642 | unsigned int copy; | ||
643 | unsigned int x; | ||
644 | |||
645 | ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize); | ||
646 | for (x = 0; x < ea->ea_num_ptrs; x++) { | ||
647 | struct buffer_head *bh; | ||
648 | u64 block; | ||
649 | int mh_size = sizeof(struct gfs2_meta_header); | ||
650 | unsigned int n = 1; | ||
651 | |||
652 | error = gfs2_alloc_block(ip, &block, &n); | ||
653 | if (error) | ||
654 | return error; | ||
655 | gfs2_trans_add_unrevoke(sdp, block, 1); | ||
656 | bh = gfs2_meta_new(ip->i_gl, block); | ||
657 | gfs2_trans_add_bh(ip->i_gl, bh, 1); | ||
658 | gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED); | ||
659 | |||
660 | gfs2_add_inode_blocks(&ip->i_inode, 1); | ||
661 | |||
662 | copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize : | ||
663 | data_len; | ||
664 | memcpy(bh->b_data + mh_size, data, copy); | ||
665 | if (copy < sdp->sd_jbsize) | ||
666 | memset(bh->b_data + mh_size + copy, 0, | ||
667 | sdp->sd_jbsize - copy); | ||
668 | |||
669 | *dataptr++ = cpu_to_be64(bh->b_blocknr); | ||
670 | data += copy; | ||
671 | data_len -= copy; | ||
672 | |||
673 | brelse(bh); | ||
674 | } | ||
675 | |||
676 | gfs2_assert_withdraw(sdp, !data_len); | ||
677 | } | ||
678 | |||
679 | return 0; | ||
680 | } | ||
681 | |||
682 | typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip, | ||
683 | struct gfs2_ea_request *er, void *private); | ||
684 | |||
685 | static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er, | ||
686 | unsigned int blks, | ||
687 | ea_skeleton_call_t skeleton_call, void *private) | ||
688 | { | ||
689 | struct gfs2_alloc *al; | ||
690 | struct buffer_head *dibh; | ||
691 | int error; | ||
692 | |||
693 | al = gfs2_alloc_get(ip); | ||
694 | if (!al) | ||
695 | return -ENOMEM; | ||
696 | |||
697 | error = gfs2_quota_lock_check(ip); | ||
698 | if (error) | ||
699 | goto out; | ||
700 | |||
701 | al->al_requested = blks; | ||
702 | |||
703 | error = gfs2_inplace_reserve(ip); | ||
704 | if (error) | ||
705 | goto out_gunlock_q; | ||
706 | |||
707 | error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), | ||
708 | blks + al->al_rgd->rd_length + | ||
709 | RES_DINODE + RES_STATFS + RES_QUOTA, 0); | ||
710 | if (error) | ||
711 | goto out_ipres; | ||
712 | |||
713 | error = skeleton_call(ip, er, private); | ||
714 | if (error) | ||
715 | goto out_end_trans; | ||
716 | |||
717 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
718 | if (!error) { | ||
719 | ip->i_inode.i_ctime = CURRENT_TIME; | ||
720 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
721 | gfs2_dinode_out(ip, dibh->b_data); | ||
722 | brelse(dibh); | ||
723 | } | ||
724 | |||
725 | out_end_trans: | ||
726 | gfs2_trans_end(GFS2_SB(&ip->i_inode)); | ||
727 | out_ipres: | ||
728 | gfs2_inplace_release(ip); | ||
729 | out_gunlock_q: | ||
730 | gfs2_quota_unlock(ip); | ||
731 | out: | ||
732 | gfs2_alloc_put(ip); | ||
733 | return error; | ||
734 | } | ||
735 | |||
736 | static int ea_init_i(struct gfs2_inode *ip, struct gfs2_ea_request *er, | ||
737 | void *private) | ||
738 | { | ||
739 | struct buffer_head *bh; | ||
740 | int error; | ||
741 | |||
742 | error = ea_alloc_blk(ip, &bh); | ||
743 | if (error) | ||
744 | return error; | ||
745 | |||
746 | ip->i_eattr = bh->b_blocknr; | ||
747 | error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er); | ||
748 | |||
749 | brelse(bh); | ||
750 | |||
751 | return error; | ||
752 | } | ||
753 | |||
754 | /** | ||
755 | * ea_init - initializes a new eattr block | ||
756 | * @ip: | ||
757 | * @er: | ||
758 | * | ||
759 | * Returns: errno | ||
760 | */ | ||
761 | |||
762 | static int ea_init(struct gfs2_inode *ip, int type, const char *name, | ||
763 | const void *data, size_t size) | ||
764 | { | ||
765 | struct gfs2_ea_request er; | ||
766 | unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize; | ||
767 | unsigned int blks = 1; | ||
768 | |||
769 | er.er_type = type; | ||
770 | er.er_name = name; | ||
771 | er.er_name_len = strlen(name); | ||
772 | er.er_data = (void *)data; | ||
773 | er.er_data_len = size; | ||
774 | |||
775 | if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize) | ||
776 | blks += DIV_ROUND_UP(er.er_data_len, jbsize); | ||
777 | |||
778 | return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL); | ||
779 | } | ||
780 | |||
781 | static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea) | ||
782 | { | ||
783 | u32 ea_size = GFS2_EA_SIZE(ea); | ||
784 | struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea + | ||
785 | ea_size); | ||
786 | u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size; | ||
787 | int last = ea->ea_flags & GFS2_EAFLAG_LAST; | ||
788 | |||
789 | ea->ea_rec_len = cpu_to_be32(ea_size); | ||
790 | ea->ea_flags ^= last; | ||
791 | |||
792 | new->ea_rec_len = cpu_to_be32(new_size); | ||
793 | new->ea_flags = last; | ||
794 | |||
795 | return new; | ||
796 | } | ||
797 | |||
798 | static void ea_set_remove_stuffed(struct gfs2_inode *ip, | ||
799 | struct gfs2_ea_location *el) | ||
800 | { | ||
801 | struct gfs2_ea_header *ea = el->el_ea; | ||
802 | struct gfs2_ea_header *prev = el->el_prev; | ||
803 | u32 len; | ||
804 | |||
805 | gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1); | ||
806 | |||
807 | if (!prev || !GFS2_EA_IS_STUFFED(ea)) { | ||
808 | ea->ea_type = GFS2_EATYPE_UNUSED; | ||
809 | return; | ||
810 | } else if (GFS2_EA2NEXT(prev) != ea) { | ||
811 | prev = GFS2_EA2NEXT(prev); | ||
812 | gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea); | ||
813 | } | ||
814 | |||
815 | len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea); | ||
816 | prev->ea_rec_len = cpu_to_be32(len); | ||
817 | |||
818 | if (GFS2_EA_IS_LAST(ea)) | ||
819 | prev->ea_flags |= GFS2_EAFLAG_LAST; | ||
820 | } | ||
821 | |||
822 | struct ea_set { | ||
823 | int ea_split; | ||
824 | |||
825 | struct gfs2_ea_request *es_er; | ||
826 | struct gfs2_ea_location *es_el; | ||
827 | |||
828 | struct buffer_head *es_bh; | ||
829 | struct gfs2_ea_header *es_ea; | ||
830 | }; | ||
831 | |||
832 | static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh, | ||
833 | struct gfs2_ea_header *ea, struct ea_set *es) | ||
834 | { | ||
835 | struct gfs2_ea_request *er = es->es_er; | ||
836 | struct buffer_head *dibh; | ||
837 | int error; | ||
838 | |||
839 | error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0); | ||
840 | if (error) | ||
841 | return error; | ||
842 | |||
843 | gfs2_trans_add_bh(ip->i_gl, bh, 1); | ||
844 | |||
845 | if (es->ea_split) | ||
846 | ea = ea_split_ea(ea); | ||
847 | |||
848 | ea_write(ip, ea, er); | ||
849 | |||
850 | if (es->es_el) | ||
851 | ea_set_remove_stuffed(ip, es->es_el); | ||
852 | |||
853 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
854 | if (error) | ||
855 | goto out; | ||
856 | ip->i_inode.i_ctime = CURRENT_TIME; | ||
857 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
858 | gfs2_dinode_out(ip, dibh->b_data); | ||
859 | brelse(dibh); | ||
860 | out: | ||
861 | gfs2_trans_end(GFS2_SB(&ip->i_inode)); | ||
862 | return error; | ||
863 | } | ||
864 | |||
865 | static int ea_set_simple_alloc(struct gfs2_inode *ip, | ||
866 | struct gfs2_ea_request *er, void *private) | ||
867 | { | ||
868 | struct ea_set *es = private; | ||
869 | struct gfs2_ea_header *ea = es->es_ea; | ||
870 | int error; | ||
871 | |||
872 | gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1); | ||
873 | |||
874 | if (es->ea_split) | ||
875 | ea = ea_split_ea(ea); | ||
876 | |||
877 | error = ea_write(ip, ea, er); | ||
878 | if (error) | ||
879 | return error; | ||
880 | |||
881 | if (es->es_el) | ||
882 | ea_set_remove_stuffed(ip, es->es_el); | ||
883 | |||
884 | return 0; | ||
885 | } | ||
886 | |||
887 | static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh, | ||
888 | struct gfs2_ea_header *ea, struct gfs2_ea_header *prev, | ||
889 | void *private) | ||
890 | { | ||
891 | struct ea_set *es = private; | ||
892 | unsigned int size; | ||
893 | int stuffed; | ||
894 | int error; | ||
895 | |||
896 | stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len, | ||
897 | es->es_er->er_data_len, &size); | ||
898 | |||
899 | if (ea->ea_type == GFS2_EATYPE_UNUSED) { | ||
900 | if (GFS2_EA_REC_LEN(ea) < size) | ||
901 | return 0; | ||
902 | if (!GFS2_EA_IS_STUFFED(ea)) { | ||
903 | error = ea_remove_unstuffed(ip, bh, ea, prev, 1); | ||
904 | if (error) | ||
905 | return error; | ||
906 | } | ||
907 | es->ea_split = 0; | ||
908 | } else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size) | ||
909 | es->ea_split = 1; | ||
910 | else | ||
911 | return 0; | ||
912 | |||
913 | if (stuffed) { | ||
914 | error = ea_set_simple_noalloc(ip, bh, ea, es); | ||
915 | if (error) | ||
916 | return error; | ||
917 | } else { | ||
918 | unsigned int blks; | ||
919 | |||
920 | es->es_bh = bh; | ||
921 | es->es_ea = ea; | ||
922 | blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len, | ||
923 | GFS2_SB(&ip->i_inode)->sd_jbsize); | ||
924 | |||
925 | error = ea_alloc_skeleton(ip, es->es_er, blks, | ||
926 | ea_set_simple_alloc, es); | ||
927 | if (error) | ||
928 | return error; | ||
929 | } | ||
930 | |||
931 | return 1; | ||
932 | } | ||
933 | |||
934 | static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er, | ||
935 | void *private) | ||
936 | { | ||
937 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
938 | struct buffer_head *indbh, *newbh; | ||
939 | __be64 *eablk; | ||
940 | int error; | ||
941 | int mh_size = sizeof(struct gfs2_meta_header); | ||
942 | |||
943 | if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) { | ||
944 | __be64 *end; | ||
945 | |||
946 | error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, | ||
947 | &indbh); | ||
948 | if (error) | ||
949 | return error; | ||
950 | |||
951 | if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) { | ||
952 | error = -EIO; | ||
953 | goto out; | ||
954 | } | ||
955 | |||
956 | eablk = (__be64 *)(indbh->b_data + mh_size); | ||
957 | end = eablk + sdp->sd_inptrs; | ||
958 | |||
959 | for (; eablk < end; eablk++) | ||
960 | if (!*eablk) | ||
961 | break; | ||
962 | |||
963 | if (eablk == end) { | ||
964 | error = -ENOSPC; | ||
965 | goto out; | ||
966 | } | ||
967 | |||
968 | gfs2_trans_add_bh(ip->i_gl, indbh, 1); | ||
969 | } else { | ||
970 | u64 blk; | ||
971 | unsigned int n = 1; | ||
972 | error = gfs2_alloc_block(ip, &blk, &n); | ||
973 | if (error) | ||
974 | return error; | ||
975 | gfs2_trans_add_unrevoke(sdp, blk, 1); | ||
976 | indbh = gfs2_meta_new(ip->i_gl, blk); | ||
977 | gfs2_trans_add_bh(ip->i_gl, indbh, 1); | ||
978 | gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN); | ||
979 | gfs2_buffer_clear_tail(indbh, mh_size); | ||
980 | |||
981 | eablk = (__be64 *)(indbh->b_data + mh_size); | ||
982 | *eablk = cpu_to_be64(ip->i_eattr); | ||
983 | ip->i_eattr = blk; | ||
984 | ip->i_diskflags |= GFS2_DIF_EA_INDIRECT; | ||
985 | gfs2_add_inode_blocks(&ip->i_inode, 1); | ||
986 | |||
987 | eablk++; | ||
988 | } | ||
989 | |||
990 | error = ea_alloc_blk(ip, &newbh); | ||
991 | if (error) | ||
992 | goto out; | ||
993 | |||
994 | *eablk = cpu_to_be64((u64)newbh->b_blocknr); | ||
995 | error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er); | ||
996 | brelse(newbh); | ||
997 | if (error) | ||
998 | goto out; | ||
999 | |||
1000 | if (private) | ||
1001 | ea_set_remove_stuffed(ip, private); | ||
1002 | |||
1003 | out: | ||
1004 | brelse(indbh); | ||
1005 | return error; | ||
1006 | } | ||
1007 | |||
1008 | static int ea_set_i(struct gfs2_inode *ip, int type, const char *name, | ||
1009 | const void *value, size_t size, struct gfs2_ea_location *el) | ||
1010 | { | ||
1011 | struct gfs2_ea_request er; | ||
1012 | struct ea_set es; | ||
1013 | unsigned int blks = 2; | ||
1014 | int error; | ||
1015 | |||
1016 | er.er_type = type; | ||
1017 | er.er_name = name; | ||
1018 | er.er_data = (void *)value; | ||
1019 | er.er_name_len = strlen(name); | ||
1020 | er.er_data_len = size; | ||
1021 | |||
1022 | memset(&es, 0, sizeof(struct ea_set)); | ||
1023 | es.es_er = &er; | ||
1024 | es.es_el = el; | ||
1025 | |||
1026 | error = ea_foreach(ip, ea_set_simple, &es); | ||
1027 | if (error > 0) | ||
1028 | return 0; | ||
1029 | if (error) | ||
1030 | return error; | ||
1031 | |||
1032 | if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) | ||
1033 | blks++; | ||
1034 | if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize) | ||
1035 | blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize); | ||
1036 | |||
1037 | return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el); | ||
1038 | } | ||
1039 | |||
1040 | static int ea_set_remove_unstuffed(struct gfs2_inode *ip, | ||
1041 | struct gfs2_ea_location *el) | ||
1042 | { | ||
1043 | if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) { | ||
1044 | el->el_prev = GFS2_EA2NEXT(el->el_prev); | ||
1045 | gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), | ||
1046 | GFS2_EA2NEXT(el->el_prev) == el->el_ea); | ||
1047 | } | ||
1048 | |||
1049 | return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev,0); | ||
1050 | } | ||
1051 | |||
1052 | static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el) | ||
1053 | { | ||
1054 | struct gfs2_ea_header *ea = el->el_ea; | ||
1055 | struct gfs2_ea_header *prev = el->el_prev; | ||
1056 | struct buffer_head *dibh; | ||
1057 | int error; | ||
1058 | |||
1059 | error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0); | ||
1060 | if (error) | ||
1061 | return error; | ||
1062 | |||
1063 | gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1); | ||
1064 | |||
1065 | if (prev) { | ||
1066 | u32 len; | ||
1067 | |||
1068 | len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea); | ||
1069 | prev->ea_rec_len = cpu_to_be32(len); | ||
1070 | |||
1071 | if (GFS2_EA_IS_LAST(ea)) | ||
1072 | prev->ea_flags |= GFS2_EAFLAG_LAST; | ||
1073 | } else { | ||
1074 | ea->ea_type = GFS2_EATYPE_UNUSED; | ||
1075 | } | ||
1076 | |||
1077 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
1078 | if (!error) { | ||
1079 | ip->i_inode.i_ctime = CURRENT_TIME; | ||
1080 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
1081 | gfs2_dinode_out(ip, dibh->b_data); | ||
1082 | brelse(dibh); | ||
1083 | } | ||
1084 | |||
1085 | gfs2_trans_end(GFS2_SB(&ip->i_inode)); | ||
1086 | |||
1087 | return error; | ||
1088 | } | ||
1089 | |||
1090 | /** | ||
1091 | * gfs2_xattr_remove - Remove a GFS2 extended attribute | ||
1092 | * @inode: The inode | ||
1093 | * @type: The type of the extended attribute | ||
1094 | * @name: The name of the extended attribute | ||
1095 | * | ||
1096 | * This is not called directly by the VFS since we use the (common) | ||
1097 | * scheme of making a "set with NULL data" mean a remove request. Note | ||
1098 | * that this is different from a set with zero length data. | ||
1099 | * | ||
1100 | * Returns: 0, or errno on failure | ||
1101 | */ | ||
1102 | |||
1103 | static int gfs2_xattr_remove(struct inode *inode, int type, const char *name) | ||
1104 | { | ||
1105 | struct gfs2_inode *ip = GFS2_I(inode); | ||
1106 | struct gfs2_ea_location el; | ||
1107 | int error; | ||
1108 | |||
1109 | if (!ip->i_eattr) | ||
1110 | return -ENODATA; | ||
1111 | |||
1112 | error = gfs2_ea_find(ip, type, name, &el); | ||
1113 | if (error) | ||
1114 | return error; | ||
1115 | if (!el.el_ea) | ||
1116 | return -ENODATA; | ||
1117 | |||
1118 | if (GFS2_EA_IS_STUFFED(el.el_ea)) | ||
1119 | error = ea_remove_stuffed(ip, &el); | ||
1120 | else | ||
1121 | error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0); | ||
1122 | |||
1123 | brelse(el.el_bh); | ||
1124 | |||
1125 | return error; | ||
1126 | } | ||
1127 | |||
1128 | /** | ||
1129 | * gfs2_xattr_set - Set (or remove) a GFS2 extended attribute | ||
1130 | * @inode: The inode | ||
1131 | * @type: The type of the extended attribute | ||
1132 | * @name: The name of the extended attribute | ||
1133 | * @value: The value of the extended attribute (NULL for remove) | ||
1134 | * @size: The size of the @value argument | ||
1135 | * @flags: Create or Replace | ||
1136 | * | ||
1137 | * See gfs2_xattr_remove() for details of the removal of xattrs. | ||
1138 | * | ||
1139 | * Returns: 0 or errno on failure | ||
1140 | */ | ||
1141 | |||
1142 | int gfs2_xattr_set(struct inode *inode, int type, const char *name, | ||
1143 | const void *value, size_t size, int flags) | ||
1144 | { | ||
1145 | struct gfs2_sbd *sdp = GFS2_SB(inode); | ||
1146 | struct gfs2_inode *ip = GFS2_I(inode); | ||
1147 | struct gfs2_ea_location el; | ||
1148 | unsigned int namel = strlen(name); | ||
1149 | int error; | ||
1150 | |||
1151 | if (IS_IMMUTABLE(inode) || IS_APPEND(inode)) | ||
1152 | return -EPERM; | ||
1153 | if (namel > GFS2_EA_MAX_NAME_LEN) | ||
1154 | return -ERANGE; | ||
1155 | |||
1156 | if (value == NULL) | ||
1157 | return gfs2_xattr_remove(inode, type, name); | ||
1158 | |||
1159 | if (ea_check_size(sdp, namel, size)) | ||
1160 | return -ERANGE; | ||
1161 | |||
1162 | if (!ip->i_eattr) { | ||
1163 | if (flags & XATTR_REPLACE) | ||
1164 | return -ENODATA; | ||
1165 | return ea_init(ip, type, name, value, size); | ||
1166 | } | ||
1167 | |||
1168 | error = gfs2_ea_find(ip, type, name, &el); | ||
1169 | if (error) | ||
1170 | return error; | ||
1171 | |||
1172 | if (el.el_ea) { | ||
1173 | if (ip->i_diskflags & GFS2_DIF_APPENDONLY) { | ||
1174 | brelse(el.el_bh); | ||
1175 | return -EPERM; | ||
1176 | } | ||
1177 | |||
1178 | error = -EEXIST; | ||
1179 | if (!(flags & XATTR_CREATE)) { | ||
1180 | int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea); | ||
1181 | error = ea_set_i(ip, type, name, value, size, &el); | ||
1182 | if (!error && unstuffed) | ||
1183 | ea_set_remove_unstuffed(ip, &el); | ||
1184 | } | ||
1185 | |||
1186 | brelse(el.el_bh); | ||
1187 | return error; | ||
1188 | } | ||
1189 | |||
1190 | error = -ENODATA; | ||
1191 | if (!(flags & XATTR_REPLACE)) | ||
1192 | error = ea_set_i(ip, type, name, value, size, NULL); | ||
1193 | |||
1194 | return error; | ||
1195 | } | ||
1196 | |||
1197 | static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip, | ||
1198 | struct gfs2_ea_header *ea, char *data) | ||
1199 | { | ||
1200 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
1201 | struct buffer_head **bh; | ||
1202 | unsigned int amount = GFS2_EA_DATA_LEN(ea); | ||
1203 | unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize); | ||
1204 | __be64 *dataptrs = GFS2_EA2DATAPTRS(ea); | ||
1205 | unsigned int x; | ||
1206 | int error; | ||
1207 | |||
1208 | bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS); | ||
1209 | if (!bh) | ||
1210 | return -ENOMEM; | ||
1211 | |||
1212 | error = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0); | ||
1213 | if (error) | ||
1214 | goto out; | ||
1215 | |||
1216 | for (x = 0; x < nptrs; x++) { | ||
1217 | error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0, | ||
1218 | bh + x); | ||
1219 | if (error) { | ||
1220 | while (x--) | ||
1221 | brelse(bh[x]); | ||
1222 | goto fail; | ||
1223 | } | ||
1224 | dataptrs++; | ||
1225 | } | ||
1226 | |||
1227 | for (x = 0; x < nptrs; x++) { | ||
1228 | error = gfs2_meta_wait(sdp, bh[x]); | ||
1229 | if (error) { | ||
1230 | for (; x < nptrs; x++) | ||
1231 | brelse(bh[x]); | ||
1232 | goto fail; | ||
1233 | } | ||
1234 | if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) { | ||
1235 | for (; x < nptrs; x++) | ||
1236 | brelse(bh[x]); | ||
1237 | error = -EIO; | ||
1238 | goto fail; | ||
1239 | } | ||
1240 | |||
1241 | gfs2_trans_add_bh(ip->i_gl, bh[x], 1); | ||
1242 | |||
1243 | memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data, | ||
1244 | (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize); | ||
1245 | |||
1246 | amount -= sdp->sd_jbsize; | ||
1247 | data += sdp->sd_jbsize; | ||
1248 | |||
1249 | brelse(bh[x]); | ||
1250 | } | ||
1251 | |||
1252 | out: | ||
1253 | kfree(bh); | ||
1254 | return error; | ||
1255 | |||
1256 | fail: | ||
1257 | gfs2_trans_end(sdp); | ||
1258 | kfree(bh); | ||
1259 | return error; | ||
1260 | } | ||
1261 | |||
1262 | int gfs2_ea_acl_chmod(struct gfs2_inode *ip, struct gfs2_ea_location *el, | ||
1263 | struct iattr *attr, char *data) | ||
1264 | { | ||
1265 | struct buffer_head *dibh; | ||
1266 | int error; | ||
1267 | |||
1268 | if (GFS2_EA_IS_STUFFED(el->el_ea)) { | ||
1269 | error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0); | ||
1270 | if (error) | ||
1271 | return error; | ||
1272 | |||
1273 | gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1); | ||
1274 | memcpy(GFS2_EA2DATA(el->el_ea), data, | ||
1275 | GFS2_EA_DATA_LEN(el->el_ea)); | ||
1276 | } else | ||
1277 | error = ea_acl_chmod_unstuffed(ip, el->el_ea, data); | ||
1278 | |||
1279 | if (error) | ||
1280 | return error; | ||
1281 | |||
1282 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
1283 | if (!error) { | ||
1284 | error = inode_setattr(&ip->i_inode, attr); | ||
1285 | gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); | ||
1286 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
1287 | gfs2_dinode_out(ip, dibh->b_data); | ||
1288 | brelse(dibh); | ||
1289 | } | ||
1290 | |||
1291 | gfs2_trans_end(GFS2_SB(&ip->i_inode)); | ||
1292 | |||
1293 | return error; | ||
1294 | } | ||
1295 | |||
1296 | static int ea_dealloc_indirect(struct gfs2_inode *ip) | ||
1297 | { | ||
1298 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
1299 | struct gfs2_rgrp_list rlist; | ||
1300 | struct buffer_head *indbh, *dibh; | ||
1301 | __be64 *eablk, *end; | ||
1302 | unsigned int rg_blocks = 0; | ||
1303 | u64 bstart = 0; | ||
1304 | unsigned int blen = 0; | ||
1305 | unsigned int blks = 0; | ||
1306 | unsigned int x; | ||
1307 | int error; | ||
1308 | |||
1309 | memset(&rlist, 0, sizeof(struct gfs2_rgrp_list)); | ||
1310 | |||
1311 | error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh); | ||
1312 | if (error) | ||
1313 | return error; | ||
1314 | |||
1315 | if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) { | ||
1316 | error = -EIO; | ||
1317 | goto out; | ||
1318 | } | ||
1319 | |||
1320 | eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header)); | ||
1321 | end = eablk + sdp->sd_inptrs; | ||
1322 | |||
1323 | for (; eablk < end; eablk++) { | ||
1324 | u64 bn; | ||
1325 | |||
1326 | if (!*eablk) | ||
1327 | break; | ||
1328 | bn = be64_to_cpu(*eablk); | ||
1329 | |||
1330 | if (bstart + blen == bn) | ||
1331 | blen++; | ||
1332 | else { | ||
1333 | if (bstart) | ||
1334 | gfs2_rlist_add(sdp, &rlist, bstart); | ||
1335 | bstart = bn; | ||
1336 | blen = 1; | ||
1337 | } | ||
1338 | blks++; | ||
1339 | } | ||
1340 | if (bstart) | ||
1341 | gfs2_rlist_add(sdp, &rlist, bstart); | ||
1342 | else | ||
1343 | goto out; | ||
1344 | |||
1345 | gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE); | ||
1346 | |||
1347 | for (x = 0; x < rlist.rl_rgrps; x++) { | ||
1348 | struct gfs2_rgrpd *rgd; | ||
1349 | rgd = rlist.rl_ghs[x].gh_gl->gl_object; | ||
1350 | rg_blocks += rgd->rd_length; | ||
1351 | } | ||
1352 | |||
1353 | error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs); | ||
1354 | if (error) | ||
1355 | goto out_rlist_free; | ||
1356 | |||
1357 | error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT + | ||
1358 | RES_STATFS + RES_QUOTA, blks); | ||
1359 | if (error) | ||
1360 | goto out_gunlock; | ||
1361 | |||
1362 | gfs2_trans_add_bh(ip->i_gl, indbh, 1); | ||
1363 | |||
1364 | eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header)); | ||
1365 | bstart = 0; | ||
1366 | blen = 0; | ||
1367 | |||
1368 | for (; eablk < end; eablk++) { | ||
1369 | u64 bn; | ||
1370 | |||
1371 | if (!*eablk) | ||
1372 | break; | ||
1373 | bn = be64_to_cpu(*eablk); | ||
1374 | |||
1375 | if (bstart + blen == bn) | ||
1376 | blen++; | ||
1377 | else { | ||
1378 | if (bstart) | ||
1379 | gfs2_free_meta(ip, bstart, blen); | ||
1380 | bstart = bn; | ||
1381 | blen = 1; | ||
1382 | } | ||
1383 | |||
1384 | *eablk = 0; | ||
1385 | gfs2_add_inode_blocks(&ip->i_inode, -1); | ||
1386 | } | ||
1387 | if (bstart) | ||
1388 | gfs2_free_meta(ip, bstart, blen); | ||
1389 | |||
1390 | ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT; | ||
1391 | |||
1392 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
1393 | if (!error) { | ||
1394 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
1395 | gfs2_dinode_out(ip, dibh->b_data); | ||
1396 | brelse(dibh); | ||
1397 | } | ||
1398 | |||
1399 | gfs2_trans_end(sdp); | ||
1400 | |||
1401 | out_gunlock: | ||
1402 | gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs); | ||
1403 | out_rlist_free: | ||
1404 | gfs2_rlist_free(&rlist); | ||
1405 | out: | ||
1406 | brelse(indbh); | ||
1407 | return error; | ||
1408 | } | ||
1409 | |||
1410 | static int ea_dealloc_block(struct gfs2_inode *ip) | ||
1411 | { | ||
1412 | struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode); | ||
1413 | struct gfs2_alloc *al = ip->i_alloc; | ||
1414 | struct gfs2_rgrpd *rgd; | ||
1415 | struct buffer_head *dibh; | ||
1416 | int error; | ||
1417 | |||
1418 | rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr); | ||
1419 | if (!rgd) { | ||
1420 | gfs2_consist_inode(ip); | ||
1421 | return -EIO; | ||
1422 | } | ||
1423 | |||
1424 | error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, | ||
1425 | &al->al_rgd_gh); | ||
1426 | if (error) | ||
1427 | return error; | ||
1428 | |||
1429 | error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS + | ||
1430 | RES_QUOTA, 1); | ||
1431 | if (error) | ||
1432 | goto out_gunlock; | ||
1433 | |||
1434 | gfs2_free_meta(ip, ip->i_eattr, 1); | ||
1435 | |||
1436 | ip->i_eattr = 0; | ||
1437 | gfs2_add_inode_blocks(&ip->i_inode, -1); | ||
1438 | |||
1439 | error = gfs2_meta_inode_buffer(ip, &dibh); | ||
1440 | if (!error) { | ||
1441 | gfs2_trans_add_bh(ip->i_gl, dibh, 1); | ||
1442 | gfs2_dinode_out(ip, dibh->b_data); | ||
1443 | brelse(dibh); | ||
1444 | } | ||
1445 | |||
1446 | gfs2_trans_end(sdp); | ||
1447 | |||
1448 | out_gunlock: | ||
1449 | gfs2_glock_dq_uninit(&al->al_rgd_gh); | ||
1450 | return error; | ||
1451 | } | ||
1452 | |||
1453 | /** | ||
1454 | * gfs2_ea_dealloc - deallocate the extended attribute fork | ||
1455 | * @ip: the inode | ||
1456 | * | ||
1457 | * Returns: errno | ||
1458 | */ | ||
1459 | |||
1460 | int gfs2_ea_dealloc(struct gfs2_inode *ip) | ||
1461 | { | ||
1462 | struct gfs2_alloc *al; | ||
1463 | int error; | ||
1464 | |||
1465 | al = gfs2_alloc_get(ip); | ||
1466 | if (!al) | ||
1467 | return -ENOMEM; | ||
1468 | |||
1469 | error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE); | ||
1470 | if (error) | ||
1471 | goto out_alloc; | ||
1472 | |||
1473 | error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh); | ||
1474 | if (error) | ||
1475 | goto out_quota; | ||
1476 | |||
1477 | error = ea_foreach(ip, ea_dealloc_unstuffed, NULL); | ||
1478 | if (error) | ||
1479 | goto out_rindex; | ||
1480 | |||
1481 | if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) { | ||
1482 | error = ea_dealloc_indirect(ip); | ||
1483 | if (error) | ||
1484 | goto out_rindex; | ||
1485 | } | ||
1486 | |||
1487 | error = ea_dealloc_block(ip); | ||
1488 | |||
1489 | out_rindex: | ||
1490 | gfs2_glock_dq_uninit(&al->al_ri_gh); | ||
1491 | out_quota: | ||
1492 | gfs2_quota_unhold(ip); | ||
1493 | out_alloc: | ||
1494 | gfs2_alloc_put(ip); | ||
1495 | return error; | ||
1496 | } | ||
1497 | |||
1498 | static int gfs2_xattr_user_get(struct inode *inode, const char *name, | ||
1499 | void *buffer, size_t size) | ||
1500 | { | ||
1501 | return gfs2_xattr_get(inode, GFS2_EATYPE_USR, name, buffer, size); | ||
1502 | } | ||
1503 | |||
1504 | static int gfs2_xattr_user_set(struct inode *inode, const char *name, | ||
1505 | const void *value, size_t size, int flags) | ||
1506 | { | ||
1507 | return gfs2_xattr_set(inode, GFS2_EATYPE_USR, name, value, size, flags); | ||
1508 | } | ||
1509 | |||
1510 | static int gfs2_xattr_system_get(struct inode *inode, const char *name, | ||
1511 | void *buffer, size_t size) | ||
1512 | { | ||
1513 | return gfs2_xattr_get(inode, GFS2_EATYPE_SYS, name, buffer, size); | ||
1514 | } | ||
1515 | |||
1516 | static int gfs2_xattr_system_set(struct inode *inode, const char *name, | ||
1517 | const void *value, size_t size, int flags) | ||
1518 | { | ||
1519 | return gfs2_xattr_set(inode, GFS2_EATYPE_SYS, name, value, size, flags); | ||
1520 | } | ||
1521 | |||
1522 | static int gfs2_xattr_security_get(struct inode *inode, const char *name, | ||
1523 | void *buffer, size_t size) | ||
1524 | { | ||
1525 | return gfs2_xattr_get(inode, GFS2_EATYPE_SECURITY, name, buffer, size); | ||
1526 | } | ||
1527 | |||
1528 | static int gfs2_xattr_security_set(struct inode *inode, const char *name, | ||
1529 | const void *value, size_t size, int flags) | ||
1530 | { | ||
1531 | return gfs2_xattr_set(inode, GFS2_EATYPE_SECURITY, name, value, size, flags); | ||
1532 | } | ||
1533 | |||
1534 | static struct xattr_handler gfs2_xattr_user_handler = { | ||
1535 | .prefix = XATTR_USER_PREFIX, | ||
1536 | .get = gfs2_xattr_user_get, | ||
1537 | .set = gfs2_xattr_user_set, | ||
1538 | }; | ||
1539 | |||
1540 | static struct xattr_handler gfs2_xattr_security_handler = { | ||
1541 | .prefix = XATTR_SECURITY_PREFIX, | ||
1542 | .get = gfs2_xattr_security_get, | ||
1543 | .set = gfs2_xattr_security_set, | ||
1544 | }; | ||
1545 | |||
1546 | static struct xattr_handler gfs2_xattr_system_handler = { | ||
1547 | .prefix = XATTR_SYSTEM_PREFIX, | ||
1548 | .get = gfs2_xattr_system_get, | ||
1549 | .set = gfs2_xattr_system_set, | ||
1550 | }; | ||
1551 | |||
1552 | struct xattr_handler *gfs2_xattr_handlers[] = { | ||
1553 | &gfs2_xattr_user_handler, | ||
1554 | &gfs2_xattr_security_handler, | ||
1555 | &gfs2_xattr_system_handler, | ||
1556 | NULL, | ||
1557 | }; | ||
1558 | |||