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