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