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