?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[GFS2] gfs2 misc endianness annotations
[linux-2.6.git] / fs / gfs2 / eattr.c
blob518f0c0786c8b140ba4da2c64db50e31fab021bb
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/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/xattr.h>
16 #include <linux/gfs2_ondisk.h>
17 #include <linux/lm_interface.h>
18 #include <asm/uaccess.h>
19
20 #include "gfs2.h"
21 #include "incore.h"
22 #include "acl.h"
23 #include "eaops.h"
24 #include "eattr.h"
25 #include "glock.h"
26 #include "inode.h"
27 #include "meta_io.h"
28 #include "quota.h"
29 #include "rgrp.h"
30 #include "trans.h"
31 #include "util.h"
32
33 /**
34 * ea_calc_size - returns the acutal number of bytes the request will take up
35 * (not counting any unstuffed data blocks)
36 * @sdp:
37 * @er:
38 * @size:
39 *
40 * Returns: 1 if the EA should be stuffed
41 */
42
43 static int ea_calc_size(struct gfs2_sbd *sdp, struct gfs2_ea_request *er,
44 unsigned int *size)
45 {
46 *size = GFS2_EAREQ_SIZE_STUFFED(er);
47 if (*size <= sdp->sd_jbsize)
48 return 1;
49
50 *size = GFS2_EAREQ_SIZE_UNSTUFFED(sdp, er);
51
52 return 0;
53 }
54
55 static int ea_check_size(struct gfs2_sbd *sdp, struct gfs2_ea_request *er)
56 {
57 unsigned int size;
58
59 if (er->er_data_len > GFS2_EA_MAX_DATA_LEN)
60 return -ERANGE;
61
62 ea_calc_size(sdp, er, &size);
63
64 /* This can only happen with 512 byte blocks */
65 if (size > sdp->sd_jbsize)
66 return -ERANGE;
67
68 return 0;
69 }
70
71 typedef int (*ea_call_t) (struct gfs2_inode *ip, struct buffer_head *bh,
72 struct gfs2_ea_header *ea,
73 struct gfs2_ea_header *prev, void *private);
74
75 static int ea_foreach_i(struct gfs2_inode *ip, struct buffer_head *bh,
76 ea_call_t ea_call, void *data)
77 {
78 struct gfs2_ea_header *ea, *prev = NULL;
79 int error = 0;
80
81 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA))
82 return -EIO;
83
84 for (ea = GFS2_EA_BH2FIRST(bh);; prev = ea, ea = GFS2_EA2NEXT(ea)) {
85 if (!GFS2_EA_REC_LEN(ea))
86 goto fail;
87 if (!(bh->b_data <= (char *)ea && (char *)GFS2_EA2NEXT(ea) <=
88 bh->b_data + bh->b_size))
89 goto fail;
90 if (!GFS2_EATYPE_VALID(ea->ea_type))
91 goto fail;
92
93 error = ea_call(ip, bh, ea, prev, data);
94 if (error)
95 return error;
96
97 if (GFS2_EA_IS_LAST(ea)) {
98 if ((char *)GFS2_EA2NEXT(ea) !=
99 bh->b_data + bh->b_size)
100 goto fail;
101 break;
102 }
103 }
104
105 return error;
106
107 fail:
108 gfs2_consist_inode(ip);
109 return -EIO;
110 }
111
112 static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data)
113 {
114 struct buffer_head *bh, *eabh;
115 __be64 *eablk, *end;
116 int error;
117
118 error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT, &bh);
119 if (error)
120 return error;
121
122 if (!(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT)) {
123 error = ea_foreach_i(ip, bh, ea_call, data);
124 goto out;
125 }
126
127 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) {
128 error = -EIO;
129 goto out;
130 }
131
132 eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header));
133 end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;
134
135 for (; eablk < end; eablk++) {
136 u64 bn;
137
138 if (!*eablk)
139 break;
140 bn = be64_to_cpu(*eablk);
141
142 error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh);
143 if (error)
144 break;
145 error = ea_foreach_i(ip, eabh, ea_call, data);
146 brelse(eabh);
147 if (error)
148 break;
149 }
150 out:
151 brelse(bh);
152 return error;
153 }
154
155 struct ea_find {
156 struct gfs2_ea_request *ef_er;
157 struct gfs2_ea_location *ef_el;
158 };
159
160 static int ea_find_i(struct gfs2_inode *ip, struct buffer_head *bh,
161 struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
162 void *private)
163 {
164 struct ea_find *ef = private;
165 struct gfs2_ea_request *er = ef->ef_er;
166
167 if (ea->ea_type == GFS2_EATYPE_UNUSED)
168 return 0;
169
170 if (ea->ea_type == er->er_type) {
171 if (ea->ea_name_len == er->er_name_len &&
172 !memcmp(GFS2_EA2NAME(ea), er->er_name, ea->ea_name_len)) {
173 struct gfs2_ea_location *el = ef->ef_el;
174 get_bh(bh);
175 el->el_bh = bh;
176 el->el_ea = ea;
177 el->el_prev = prev;
178 return 1;
179 }
180 }
181
182 return 0;
183 }
184
185 int gfs2_ea_find(struct gfs2_inode *ip, struct gfs2_ea_request *er,
186 struct gfs2_ea_location *el)
187 {
188 struct ea_find ef;
189 int error;
190
191 ef.ef_er = er;
192 ef.ef_el = el;
193
194 memset(el, 0, sizeof(struct gfs2_ea_location));
195
196 error = ea_foreach(ip, ea_find_i, &ef);
197 if (error > 0)
198 return 0;
199
200 return error;
201 }
202
203 /**
204 * ea_dealloc_unstuffed -
205 * @ip:
206 * @bh:
207 * @ea:
208 * @prev:
209 * @private:
210 *
211 * Take advantage of the fact that all unstuffed blocks are
212 * allocated from the same RG. But watch, this may not always
213 * be true.
214 *
215 * Returns: errno
216 */
217
218 static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
219 struct gfs2_ea_header *ea,
220 struct gfs2_ea_header *prev, void *private)
221 {
222 int *leave = private;
223 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
224 struct gfs2_rgrpd *rgd;
225 struct gfs2_holder rg_gh;
226 struct buffer_head *dibh;
227 __be64 *dataptrs;
228 u64 bn = 0;
229 u64 bstart = 0;
230 unsigned int blen = 0;
231 unsigned int blks = 0;
232 unsigned int x;
233 int error;
234
235 if (GFS2_EA_IS_STUFFED(ea))
236 return 0;
237
238 dataptrs = GFS2_EA2DATAPTRS(ea);
239 for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
240 if (*dataptrs) {
241 blks++;
242 bn = be64_to_cpu(*dataptrs);
243 }
244 }
245 if (!blks)
246 return 0;
247
248 rgd = gfs2_blk2rgrpd(sdp, bn);
249 if (!rgd) {
250 gfs2_consist_inode(ip);
251 return -EIO;
252 }
253
254 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);
255 if (error)
256 return error;
257
258 error = gfs2_trans_begin(sdp, rgd->rd_ri.ri_length + RES_DINODE +
259 RES_EATTR + RES_STATFS + RES_QUOTA, blks);
260 if (error)
261 goto out_gunlock;
262
263 gfs2_trans_add_bh(ip->i_gl, bh, 1);
264
265 dataptrs = GFS2_EA2DATAPTRS(ea);
266 for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
267 if (!*dataptrs)
268 break;
269 bn = be64_to_cpu(*dataptrs);
270
271 if (bstart + blen == bn)
272 blen++;
273 else {
274 if (bstart)
275 gfs2_free_meta(ip, bstart, blen);
276 bstart = bn;
277 blen = 1;
278 }
279
280 *dataptrs = 0;
281 if (!ip->i_di.di_blocks)
282 gfs2_consist_inode(ip);
283 ip->i_di.di_blocks--;
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_di.di_ctime = get_seconds();
304 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
305 gfs2_dinode_out(&ip->i_di, 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
602 return 0;
603 }
604
605 /**
606 * ea_write - writes the request info to an ea, creating new blocks if
607 * necessary
608 * @ip: inode that is being modified
609 * @ea: the location of the new ea in a block
610 * @er: the write request
611 *
612 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
613 *
614 * returns : errno
615 */
616
617 static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
618 struct gfs2_ea_request *er)
619 {
620 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
621
622 ea->ea_data_len = cpu_to_be32(er->er_data_len);
623 ea->ea_name_len = er->er_name_len;
624 ea->ea_type = er->er_type;
625 ea->__pad = 0;
626
627 memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);
628
629 if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {
630 ea->ea_num_ptrs = 0;
631 memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);
632 } else {
633 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
634 const char *data = er->er_data;
635 unsigned int data_len = er->er_data_len;
636 unsigned int copy;
637 unsigned int x;
638
639 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
640 for (x = 0; x < ea->ea_num_ptrs; x++) {
641 struct buffer_head *bh;
642 u64 block;
643 int mh_size = sizeof(struct gfs2_meta_header);
644
645 block = gfs2_alloc_meta(ip);
646
647 bh = gfs2_meta_new(ip->i_gl, block);
648 gfs2_trans_add_bh(ip->i_gl, bh, 1);
649 gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
650
651 ip->i_di.di_blocks++;
652
653 copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
654 data_len;
655 memcpy(bh->b_data + mh_size, data, copy);
656 if (copy < sdp->sd_jbsize)
657 memset(bh->b_data + mh_size + copy, 0,
658 sdp->sd_jbsize - copy);
659
660 *dataptr++ = cpu_to_be64(bh->b_blocknr);
661 data += copy;
662 data_len -= copy;
663
664 brelse(bh);
665 }
666
667 gfs2_assert_withdraw(sdp, !data_len);
668 }
669
670 return 0;
671 }
672
673 typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
674 struct gfs2_ea_request *er, void *private);
675
676 static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
677 unsigned int blks,
678 ea_skeleton_call_t skeleton_call, void *private)
679 {
680 struct gfs2_alloc *al;
681 struct buffer_head *dibh;
682 int error;
683
684 al = gfs2_alloc_get(ip);
685
686 error = gfs2_quota_lock(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
687 if (error)
688 goto out;
689
690 error = gfs2_quota_check(ip, ip->i_di.di_uid, ip->i_di.di_gid);
691 if (error)
692 goto out_gunlock_q;
693
694 al->al_requested = blks;
695
696 error = gfs2_inplace_reserve(ip);
697 if (error)
698 goto out_gunlock_q;
699
700 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
701 blks + al->al_rgd->rd_ri.ri_length +
702 RES_DINODE + RES_STATFS + RES_QUOTA, 0);
703 if (error)
704 goto out_ipres;
705
706 error = skeleton_call(ip, er, private);
707 if (error)
708 goto out_end_trans;
709
710 error = gfs2_meta_inode_buffer(ip, &dibh);
711 if (!error) {
712 if (er->er_flags & GFS2_ERF_MODE) {
713 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
714 (ip->i_di.di_mode & S_IFMT) ==
715 (er->er_mode & S_IFMT));
716 ip->i_di.di_mode = er->er_mode;
717 }
718 ip->i_di.di_ctime = get_seconds();
719 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
720 gfs2_dinode_out(&ip->i_di, dibh->b_data);
721 brelse(dibh);
722 }
723
724 out_end_trans:
725 gfs2_trans_end(GFS2_SB(&ip->i_inode));
726 out_ipres:
727 gfs2_inplace_release(ip);
728 out_gunlock_q:
729 gfs2_quota_unlock(ip);
730 out:
731 gfs2_alloc_put(ip);
732 return error;
733 }
734
735 static int ea_init_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
736 void *private)
737 {
738 struct buffer_head *bh;
739 int error;
740
741 error = ea_alloc_blk(ip, &bh);
742 if (error)
743 return error;
744
745 ip->i_di.di_eattr = bh->b_blocknr;
746 error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
747
748 brelse(bh);
749
750 return error;
751 }
752
753 /**
754 * ea_init - initializes a new eattr block
755 * @ip:
756 * @er:
757 *
758 * Returns: errno
759 */
760
761 static int ea_init(struct gfs2_inode *ip, struct gfs2_ea_request *er)
762 {
763 unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
764 unsigned int blks = 1;
765
766 if (GFS2_EAREQ_SIZE_STUFFED(er) > jbsize)
767 blks += DIV_ROUND_UP(er->er_data_len, jbsize);
768
769 return ea_alloc_skeleton(ip, er, blks, ea_init_i, NULL);
770 }
771
772 static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
773 {
774 u32 ea_size = GFS2_EA_SIZE(ea);
775 struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
776 ea_size);
777 u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
778 int last = ea->ea_flags & GFS2_EAFLAG_LAST;
779
780 ea->ea_rec_len = cpu_to_be32(ea_size);
781 ea->ea_flags ^= last;
782
783 new->ea_rec_len = cpu_to_be32(new_size);
784 new->ea_flags = last;
785
786 return new;
787 }
788
789 static void ea_set_remove_stuffed(struct gfs2_inode *ip,
790 struct gfs2_ea_location *el)
791 {
792 struct gfs2_ea_header *ea = el->el_ea;
793 struct gfs2_ea_header *prev = el->el_prev;
794 u32 len;
795
796 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
797
798 if (!prev || !GFS2_EA_IS_STUFFED(ea)) {
799 ea->ea_type = GFS2_EATYPE_UNUSED;
800 return;
801 } else if (GFS2_EA2NEXT(prev) != ea) {
802 prev = GFS2_EA2NEXT(prev);
803 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
804 }
805
806 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
807 prev->ea_rec_len = cpu_to_be32(len);
808
809 if (GFS2_EA_IS_LAST(ea))
810 prev->ea_flags |= GFS2_EAFLAG_LAST;
811 }
812
813 struct ea_set {
814 int ea_split;
815
816 struct gfs2_ea_request *es_er;
817 struct gfs2_ea_location *es_el;
818
819 struct buffer_head *es_bh;
820 struct gfs2_ea_header *es_ea;
821 };
822
823 static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh,
824 struct gfs2_ea_header *ea, struct ea_set *es)
825 {
826 struct gfs2_ea_request *er = es->es_er;
827 struct buffer_head *dibh;
828 int error;
829
830 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
831 if (error)
832 return error;
833
834 gfs2_trans_add_bh(ip->i_gl, bh, 1);
835
836 if (es->ea_split)
837 ea = ea_split_ea(ea);
838
839 ea_write(ip, ea, er);
840
841 if (es->es_el)
842 ea_set_remove_stuffed(ip, es->es_el);
843
844 error = gfs2_meta_inode_buffer(ip, &dibh);
845 if (error)
846 goto out;
847
848 if (er->er_flags & GFS2_ERF_MODE) {
849 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
850 (ip->i_di.di_mode & S_IFMT) == (er->er_mode & S_IFMT));
851 ip->i_di.di_mode = er->er_mode;
852 }
853 ip->i_di.di_ctime = get_seconds();
854 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
855 gfs2_dinode_out(&ip->i_di, dibh->b_data);
856 brelse(dibh);
857 out:
858 gfs2_trans_end(GFS2_SB(&ip->i_inode));
859 return error;
860 }
861
862 static int ea_set_simple_alloc(struct gfs2_inode *ip,
863 struct gfs2_ea_request *er, void *private)
864 {
865 struct ea_set *es = private;
866 struct gfs2_ea_header *ea = es->es_ea;
867 int error;
868
869 gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
870
871 if (es->ea_split)
872 ea = ea_split_ea(ea);
873
874 error = ea_write(ip, ea, er);
875 if (error)
876 return error;
877
878 if (es->es_el)
879 ea_set_remove_stuffed(ip, es->es_el);
880
881 return 0;
882 }
883
884 static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh,
885 struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
886 void *private)
887 {
888 struct ea_set *es = private;
889 unsigned int size;
890 int stuffed;
891 int error;
892
893 stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er, &size);
894
895 if (ea->ea_type == GFS2_EATYPE_UNUSED) {
896 if (GFS2_EA_REC_LEN(ea) < size)
897 return 0;
898 if (!GFS2_EA_IS_STUFFED(ea)) {
899 error = ea_remove_unstuffed(ip, bh, ea, prev, 1);
900 if (error)
901 return error;
902 }
903 es->ea_split = 0;
904 } else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)
905 es->ea_split = 1;
906 else
907 return 0;
908
909 if (stuffed) {
910 error = ea_set_simple_noalloc(ip, bh, ea, es);
911 if (error)
912 return error;
913 } else {
914 unsigned int blks;
915
916 es->es_bh = bh;
917 es->es_ea = ea;
918 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
919 GFS2_SB(&ip->i_inode)->sd_jbsize);
920
921 error = ea_alloc_skeleton(ip, es->es_er, blks,
922 ea_set_simple_alloc, es);
923 if (error)
924 return error;
925 }
926
927 return 1;
928 }
929
930 static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
931 void *private)
932 {
933 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
934 struct buffer_head *indbh, *newbh;
935 __be64 *eablk;
936 int error;
937 int mh_size = sizeof(struct gfs2_meta_header);
938
939 if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT) {
940 __be64 *end;
941
942 error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT,
943 &indbh);
944 if (error)
945 return error;
946
947 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
948 error = -EIO;
949 goto out;
950 }
951
952 eablk = (__be64 *)(indbh->b_data + mh_size);
953 end = eablk + sdp->sd_inptrs;
954
955 for (; eablk < end; eablk++)
956 if (!*eablk)
957 break;
958
959 if (eablk == end) {
960 error = -ENOSPC;
961 goto out;
962 }
963
964 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
965 } else {
966 u64 blk;
967
968 blk = gfs2_alloc_meta(ip);
969
970 indbh = gfs2_meta_new(ip->i_gl, blk);
971 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
972 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
973 gfs2_buffer_clear_tail(indbh, mh_size);
974
975 eablk = (__be64 *)(indbh->b_data + mh_size);
976 *eablk = cpu_to_be64(ip->i_di.di_eattr);
977 ip->i_di.di_eattr = blk;
978 ip->i_di.di_flags |= GFS2_DIF_EA_INDIRECT;
979 ip->i_di.di_blocks++;
980
981 eablk++;
982 }
983
984 error = ea_alloc_blk(ip, &newbh);
985 if (error)
986 goto out;
987
988 *eablk = cpu_to_be64((u64)newbh->b_blocknr);
989 error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
990 brelse(newbh);
991 if (error)
992 goto out;
993
994 if (private)
995 ea_set_remove_stuffed(ip, private);
996
997 out:
998 brelse(indbh);
999 return error;
1000 }
1001
1002 static int ea_set_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
1003 struct gfs2_ea_location *el)
1004 {
1005 struct ea_set es;
1006 unsigned int blks = 2;
1007 int error;
1008
1009 memset(&es, 0, sizeof(struct ea_set));
1010 es.es_er = er;
1011 es.es_el = el;
1012
1013 error = ea_foreach(ip, ea_set_simple, &es);
1014 if (error > 0)
1015 return 0;
1016 if (error)
1017 return error;
1018
1019 if (!(ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT))
1020 blks++;
1021 if (GFS2_EAREQ_SIZE_STUFFED(er) > GFS2_SB(&ip->i_inode)->sd_jbsize)
1022 blks += DIV_ROUND_UP(er->er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);
1023
1024 return ea_alloc_skeleton(ip, er, blks, ea_set_block, el);
1025 }
1026
1027 static int ea_set_remove_unstuffed(struct gfs2_inode *ip,
1028 struct gfs2_ea_location *el)
1029 {
1030 if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {
1031 el->el_prev = GFS2_EA2NEXT(el->el_prev);
1032 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
1033 GFS2_EA2NEXT(el->el_prev) == el->el_ea);
1034 }
1035
1036 return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev,0);
1037 }
1038
1039 int gfs2_ea_set_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1040 {
1041 struct gfs2_ea_location el;
1042 int error;
1043
1044 if (!ip->i_di.di_eattr) {
1045 if (er->er_flags & XATTR_REPLACE)
1046 return -ENODATA;
1047 return ea_init(ip, er);
1048 }
1049
1050 error = gfs2_ea_find(ip, er, &el);
1051 if (error)
1052 return error;
1053
1054 if (el.el_ea) {
1055 if (ip->i_di.di_flags & GFS2_DIF_APPENDONLY) {
1056 brelse(el.el_bh);
1057 return -EPERM;
1058 }
1059
1060 error = -EEXIST;
1061 if (!(er->er_flags & XATTR_CREATE)) {
1062 int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);
1063 error = ea_set_i(ip, er, &el);
1064 if (!error && unstuffed)
1065 ea_set_remove_unstuffed(ip, &el);
1066 }
1067
1068 brelse(el.el_bh);
1069 } else {
1070 error = -ENODATA;
1071 if (!(er->er_flags & XATTR_REPLACE))
1072 error = ea_set_i(ip, er, NULL);
1073 }
1074
1075 return error;
1076 }
1077
1078 int gfs2_ea_set(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1079 {
1080 struct gfs2_holder i_gh;
1081 int error;
1082
1083 if (!er->er_name_len || er->er_name_len > GFS2_EA_MAX_NAME_LEN)
1084 return -EINVAL;
1085 if (!er->er_data || !er->er_data_len) {
1086 er->er_data = NULL;
1087 er->er_data_len = 0;
1088 }
1089 error = ea_check_size(GFS2_SB(&ip->i_inode), er);
1090 if (error)
1091 return error;
1092
1093 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1094 if (error)
1095 return error;
1096
1097 if (IS_IMMUTABLE(&ip->i_inode))
1098 error = -EPERM;
1099 else
1100 error = gfs2_ea_ops[er->er_type]->eo_set(ip, er);
1101
1102 gfs2_glock_dq_uninit(&i_gh);
1103
1104 return error;
1105 }
1106
1107 static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el)
1108 {
1109 struct gfs2_ea_header *ea = el->el_ea;
1110 struct gfs2_ea_header *prev = el->el_prev;
1111 struct buffer_head *dibh;
1112 int error;
1113
1114 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1115 if (error)
1116 return error;
1117
1118 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
1119
1120 if (prev) {
1121 u32 len;
1122
1123 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
1124 prev->ea_rec_len = cpu_to_be32(len);
1125
1126 if (GFS2_EA_IS_LAST(ea))
1127 prev->ea_flags |= GFS2_EAFLAG_LAST;
1128 } else
1129 ea->ea_type = GFS2_EATYPE_UNUSED;
1130
1131 error = gfs2_meta_inode_buffer(ip, &dibh);
1132 if (!error) {
1133 ip->i_di.di_ctime = get_seconds();
1134 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1135 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1136 brelse(dibh);
1137 }
1138
1139 gfs2_trans_end(GFS2_SB(&ip->i_inode));
1140
1141 return error;
1142 }
1143
1144 int gfs2_ea_remove_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1145 {
1146 struct gfs2_ea_location el;
1147 int error;
1148
1149 if (!ip->i_di.di_eattr)
1150 return -ENODATA;
1151
1152 error = gfs2_ea_find(ip, er, &el);
1153 if (error)
1154 return error;
1155 if (!el.el_ea)
1156 return -ENODATA;
1157
1158 if (GFS2_EA_IS_STUFFED(el.el_ea))
1159 error = ea_remove_stuffed(ip, &el);
1160 else
1161 error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev,
1162 0);
1163
1164 brelse(el.el_bh);
1165
1166 return error;
1167 }
1168
1169 /**
1170 * gfs2_ea_remove - sets (or creates or replaces) an extended attribute
1171 * @ip: pointer to the inode of the target file
1172 * @er: request information
1173 *
1174 * Returns: errno
1175 */
1176
1177 int gfs2_ea_remove(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1178 {
1179 struct gfs2_holder i_gh;
1180 int error;
1181
1182 if (!er->er_name_len || er->er_name_len > GFS2_EA_MAX_NAME_LEN)
1183 return -EINVAL;
1184
1185 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &i_gh);
1186 if (error)
1187 return error;
1188
1189 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
1190 error = -EPERM;
1191 else
1192 error = gfs2_ea_ops[er->er_type]->eo_remove(ip, er);
1193
1194 gfs2_glock_dq_uninit(&i_gh);
1195
1196 return error;
1197 }
1198
1199 static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1200 struct gfs2_ea_header *ea, char *data)
1201 {
1202 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1203 struct buffer_head **bh;
1204 unsigned int amount = GFS2_EA_DATA_LEN(ea);
1205 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
1206 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
1207 unsigned int x;
1208 int error;
1209
1210 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_KERNEL);
1211 if (!bh)
1212 return -ENOMEM;
1213
1214 error = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0);
1215 if (error)
1216 goto out;
1217
1218 for (x = 0; x < nptrs; x++) {
1219 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
1220 bh + x);
1221 if (error) {
1222 while (x--)
1223 brelse(bh[x]);
1224 goto fail;
1225 }
1226 dataptrs++;
1227 }
1228
1229 for (x = 0; x < nptrs; x++) {
1230 error = gfs2_meta_wait(sdp, bh[x]);
1231 if (error) {
1232 for (; x < nptrs; x++)
1233 brelse(bh[x]);
1234 goto fail;
1235 }
1236 if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {
1237 for (; x < nptrs; x++)
1238 brelse(bh[x]);
1239 error = -EIO;
1240 goto fail;
1241 }
1242
1243 gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
1244
1245 memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data,
1246 (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize);
1247
1248 amount -= sdp->sd_jbsize;
1249 data += sdp->sd_jbsize;
1250
1251 brelse(bh[x]);
1252 }
1253
1254 out:
1255 kfree(bh);
1256 return error;
1257
1258 fail:
1259 gfs2_trans_end(sdp);
1260 kfree(bh);
1261 return error;
1262 }
1263
1264 int gfs2_ea_acl_chmod(struct gfs2_inode *ip, struct gfs2_ea_location *el,
1265 struct iattr *attr, char *data)
1266 {
1267 struct buffer_head *dibh;
1268 int error;
1269
1270 if (GFS2_EA_IS_STUFFED(el->el_ea)) {
1271 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1272 if (error)
1273 return error;
1274
1275 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
1276 memcpy(GFS2_EA2DATA(el->el_ea), data,
1277 GFS2_EA_DATA_LEN(el->el_ea));
1278 } else
1279 error = ea_acl_chmod_unstuffed(ip, el->el_ea, data);
1280
1281 if (error)
1282 return error;
1283
1284 error = gfs2_meta_inode_buffer(ip, &dibh);
1285 if (!error) {
1286 error = inode_setattr(&ip->i_inode, attr);
1287 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1288 gfs2_inode_attr_out(ip);
1289 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1290 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1291 brelse(dibh);
1292 }
1293
1294 gfs2_trans_end(GFS2_SB(&ip->i_inode));
1295
1296 return error;
1297 }
1298
1299 static int ea_dealloc_indirect(struct gfs2_inode *ip)
1300 {
1301 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1302 struct gfs2_rgrp_list rlist;
1303 struct buffer_head *indbh, *dibh;
1304 __be64 *eablk, *end;
1305 unsigned int rg_blocks = 0;
1306 u64 bstart = 0;
1307 unsigned int blen = 0;
1308 unsigned int blks = 0;
1309 unsigned int x;
1310 int error;
1311
1312 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1313
1314 error = gfs2_meta_read(ip->i_gl, ip->i_di.di_eattr, DIO_WAIT, &indbh);
1315 if (error)
1316 return error;
1317
1318 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1319 error = -EIO;
1320 goto out;
1321 }
1322
1323 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1324 end = eablk + sdp->sd_inptrs;
1325
1326 for (; eablk < end; eablk++) {
1327 u64 bn;
1328
1329 if (!*eablk)
1330 break;
1331 bn = be64_to_cpu(*eablk);
1332
1333 if (bstart + blen == bn)
1334 blen++;
1335 else {
1336 if (bstart)
1337 gfs2_rlist_add(sdp, &rlist, bstart);
1338 bstart = bn;
1339 blen = 1;
1340 }
1341 blks++;
1342 }
1343 if (bstart)
1344 gfs2_rlist_add(sdp, &rlist, bstart);
1345 else
1346 goto out;
1347
1348 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE, 0);
1349
1350 for (x = 0; x < rlist.rl_rgrps; x++) {
1351 struct gfs2_rgrpd *rgd;
1352 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1353 rg_blocks += rgd->rd_ri.ri_length;
1354 }
1355
1356 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1357 if (error)
1358 goto out_rlist_free;
1359
1360 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1361 RES_STATFS + RES_QUOTA, blks);
1362 if (error)
1363 goto out_gunlock;
1364
1365 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1366
1367 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1368 bstart = 0;
1369 blen = 0;
1370
1371 for (; eablk < end; eablk++) {
1372 u64 bn;
1373
1374 if (!*eablk)
1375 break;
1376 bn = be64_to_cpu(*eablk);
1377
1378 if (bstart + blen == bn)
1379 blen++;
1380 else {
1381 if (bstart)
1382 gfs2_free_meta(ip, bstart, blen);
1383 bstart = bn;
1384 blen = 1;
1385 }
1386
1387 *eablk = 0;
1388 if (!ip->i_di.di_blocks)
1389 gfs2_consist_inode(ip);
1390 ip->i_di.di_blocks--;
1391 }
1392 if (bstart)
1393 gfs2_free_meta(ip, bstart, blen);
1394
1395 ip->i_di.di_flags &= ~GFS2_DIF_EA_INDIRECT;
1396
1397 error = gfs2_meta_inode_buffer(ip, &dibh);
1398 if (!error) {
1399 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1400 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1401 brelse(dibh);
1402 }
1403
1404 gfs2_trans_end(sdp);
1405
1406 out_gunlock:
1407 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1408 out_rlist_free:
1409 gfs2_rlist_free(&rlist);
1410 out:
1411 brelse(indbh);
1412 return error;
1413 }
1414
1415 static int ea_dealloc_block(struct gfs2_inode *ip)
1416 {
1417 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1418 struct gfs2_alloc *al = &ip->i_alloc;
1419 struct gfs2_rgrpd *rgd;
1420 struct buffer_head *dibh;
1421 int error;
1422
1423 rgd = gfs2_blk2rgrpd(sdp, ip->i_di.di_eattr);
1424 if (!rgd) {
1425 gfs2_consist_inode(ip);
1426 return -EIO;
1427 }
1428
1429 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
1430 &al->al_rgd_gh);
1431 if (error)
1432 return error;
1433
1434 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1435 RES_QUOTA, 1);
1436 if (error)
1437 goto out_gunlock;
1438
1439 gfs2_free_meta(ip, ip->i_di.di_eattr, 1);
1440
1441 ip->i_di.di_eattr = 0;
1442 if (!ip->i_di.di_blocks)
1443 gfs2_consist_inode(ip);
1444 ip->i_di.di_blocks--;
1445
1446 error = gfs2_meta_inode_buffer(ip, &dibh);
1447 if (!error) {
1448 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1449 gfs2_dinode_out(&ip->i_di, dibh->b_data);
1450 brelse(dibh);
1451 }
1452
1453 gfs2_trans_end(sdp);
1454
1455 out_gunlock:
1456 gfs2_glock_dq_uninit(&al->al_rgd_gh);
1457 return error;
1458 }
1459
1460 /**
1461 * gfs2_ea_dealloc - deallocate the extended attribute fork
1462 * @ip: the inode
1463 *
1464 * Returns: errno
1465 */
1466
1467 int gfs2_ea_dealloc(struct gfs2_inode *ip)
1468 {
1469 struct gfs2_alloc *al;
1470 int error;
1471
1472 al = gfs2_alloc_get(ip);
1473
1474 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1475 if (error)
1476 goto out_alloc;
1477
1478 error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh);
1479 if (error)
1480 goto out_quota;
1481
1482 error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1483 if (error)
1484 goto out_rindex;
1485
1486 if (ip->i_di.di_flags & GFS2_DIF_EA_INDIRECT) {
1487 error = ea_dealloc_indirect(ip);
1488 if (error)
1489 goto out_rindex;
1490 }
1491
1492 error = ea_dealloc_block(ip);
1493
1494 out_rindex:
1495 gfs2_glock_dq_uninit(&al->al_ri_gh);
1496 out_quota:
1497 gfs2_quota_unhold(ip);
1498 out_alloc:
1499 gfs2_alloc_put(ip);
1500 return error;
1501 }
1502
Linus' kernel tree