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