912f5cbc4740170e32c56f63ac2d6ecf2ec9d4ac
[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  * @type: The type of extended attribute
571  * @name: The name of the extended attribute
572  * @buffer: The buffer to write the result into
573  * @size: The size of the buffer
574  *
575  * Returns: actual size of data on success, -errno on error
576  */
577
578 int gfs2_xattr_get(struct inode *inode, int type, const char *name,
579                    void *buffer, size_t size)
580 {
581         struct gfs2_inode *ip = GFS2_I(inode);
582         struct gfs2_ea_location el;
583         int error;
584
585         if (!ip->i_eattr)
586                 return -ENODATA;
587         if (strlen(name) > GFS2_EA_MAX_NAME_LEN)
588                 return -EINVAL;
589
590         error = gfs2_ea_find(ip, type, name, &el);
591         if (error)
592                 return error;
593         if (!el.el_ea)
594                 return -ENODATA;
595         if (size)
596                 error = gfs2_ea_get_copy(ip, &el, buffer, size);
597         else
598                 error = GFS2_EA_DATA_LEN(el.el_ea);
599         brelse(el.el_bh);
600
601         return error;
602 }
603
604 /**
605  * ea_alloc_blk - allocates a new block for extended attributes.
606  * @ip: A pointer to the inode that's getting extended attributes
607  * @bhp: Pointer to pointer to a struct buffer_head
608  *
609  * Returns: errno
610  */
611
612 static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp)
613 {
614         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
615         struct gfs2_ea_header *ea;
616         unsigned int n = 1;
617         u64 block;
618         int error;
619
620         error = gfs2_alloc_block(ip, &block, &n);
621         if (error)
622                 return error;
623         gfs2_trans_add_unrevoke(sdp, block, 1);
624         *bhp = gfs2_meta_new(ip->i_gl, block);
625         gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
626         gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
627         gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header));
628
629         ea = GFS2_EA_BH2FIRST(*bhp);
630         ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
631         ea->ea_type = GFS2_EATYPE_UNUSED;
632         ea->ea_flags = GFS2_EAFLAG_LAST;
633         ea->ea_num_ptrs = 0;
634
635         gfs2_add_inode_blocks(&ip->i_inode, 1);
636
637         return 0;
638 }
639
640 /**
641  * ea_write - writes the request info to an ea, creating new blocks if
642  *            necessary
643  * @ip: inode that is being modified
644  * @ea: the location of the new ea in a block
645  * @er: the write request
646  *
647  * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
648  *
649  * returns : errno
650  */
651
652 static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
653                     struct gfs2_ea_request *er)
654 {
655         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
656         int error;
657
658         ea->ea_data_len = cpu_to_be32(er->er_data_len);
659         ea->ea_name_len = er->er_name_len;
660         ea->ea_type = er->er_type;
661         ea->__pad = 0;
662
663         memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);
664
665         if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {
666                 ea->ea_num_ptrs = 0;
667                 memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);
668         } else {
669                 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
670                 const char *data = er->er_data;
671                 unsigned int data_len = er->er_data_len;
672                 unsigned int copy;
673                 unsigned int x;
674
675                 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
676                 for (x = 0; x < ea->ea_num_ptrs; x++) {
677                         struct buffer_head *bh;
678                         u64 block;
679                         int mh_size = sizeof(struct gfs2_meta_header);
680                         unsigned int n = 1;
681
682                         error = gfs2_alloc_block(ip, &block, &n);
683                         if (error)
684                                 return error;
685                         gfs2_trans_add_unrevoke(sdp, block, 1);
686                         bh = gfs2_meta_new(ip->i_gl, block);
687                         gfs2_trans_add_bh(ip->i_gl, bh, 1);
688                         gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
689
690                         gfs2_add_inode_blocks(&ip->i_inode, 1);
691
692                         copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
693                                                            data_len;
694                         memcpy(bh->b_data + mh_size, data, copy);
695                         if (copy < sdp->sd_jbsize)
696                                 memset(bh->b_data + mh_size + copy, 0,
697                                        sdp->sd_jbsize - copy);
698
699                         *dataptr++ = cpu_to_be64(bh->b_blocknr);
700                         data += copy;
701                         data_len -= copy;
702
703                         brelse(bh);
704                 }
705
706                 gfs2_assert_withdraw(sdp, !data_len);
707         }
708
709         return 0;
710 }
711
712 typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
713                                    struct gfs2_ea_request *er, void *private);
714
715 static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
716                              unsigned int blks,
717                              ea_skeleton_call_t skeleton_call, void *private)
718 {
719         struct gfs2_alloc *al;
720         struct buffer_head *dibh;
721         int error;
722
723         al = gfs2_alloc_get(ip);
724         if (!al)
725                 return -ENOMEM;
726
727         error = gfs2_quota_lock_check(ip);
728         if (error)
729                 goto out;
730
731         al->al_requested = blks;
732
733         error = gfs2_inplace_reserve(ip);
734         if (error)
735                 goto out_gunlock_q;
736
737         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
738                                  blks + al->al_rgd->rd_length +
739                                  RES_DINODE + RES_STATFS + RES_QUOTA, 0);
740         if (error)
741                 goto out_ipres;
742
743         error = skeleton_call(ip, er, private);
744         if (error)
745                 goto out_end_trans;
746
747         error = gfs2_meta_inode_buffer(ip, &dibh);
748         if (!error) {
749                 ip->i_inode.i_ctime = CURRENT_TIME;
750                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
751                 gfs2_dinode_out(ip, dibh->b_data);
752                 brelse(dibh);
753         }
754
755 out_end_trans:
756         gfs2_trans_end(GFS2_SB(&ip->i_inode));
757 out_ipres:
758         gfs2_inplace_release(ip);
759 out_gunlock_q:
760         gfs2_quota_unlock(ip);
761 out:
762         gfs2_alloc_put(ip);
763         return error;
764 }
765
766 static int ea_init_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
767                      void *private)
768 {
769         struct buffer_head *bh;
770         int error;
771
772         error = ea_alloc_blk(ip, &bh);
773         if (error)
774                 return error;
775
776         ip->i_eattr = bh->b_blocknr;
777         error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
778
779         brelse(bh);
780
781         return error;
782 }
783
784 /**
785  * ea_init - initializes a new eattr block
786  * @ip:
787  * @er:
788  *
789  * Returns: errno
790  */
791
792 static int ea_init(struct gfs2_inode *ip, int type, const char *name,
793                    const void *data, size_t size)
794 {
795         struct gfs2_ea_request er;
796         unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
797         unsigned int blks = 1;
798
799         er.er_type = type;
800         er.er_name = name;
801         er.er_name_len = strlen(name);
802         er.er_data = (void *)data;
803         er.er_data_len = size;
804
805         if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize)
806                 blks += DIV_ROUND_UP(er.er_data_len, jbsize);
807
808         return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL);
809 }
810
811 static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
812 {
813         u32 ea_size = GFS2_EA_SIZE(ea);
814         struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
815                                      ea_size);
816         u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
817         int last = ea->ea_flags & GFS2_EAFLAG_LAST;
818
819         ea->ea_rec_len = cpu_to_be32(ea_size);
820         ea->ea_flags ^= last;
821
822         new->ea_rec_len = cpu_to_be32(new_size);
823         new->ea_flags = last;
824
825         return new;
826 }
827
828 static void ea_set_remove_stuffed(struct gfs2_inode *ip,
829                                   struct gfs2_ea_location *el)
830 {
831         struct gfs2_ea_header *ea = el->el_ea;
832         struct gfs2_ea_header *prev = el->el_prev;
833         u32 len;
834
835         gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
836
837         if (!prev || !GFS2_EA_IS_STUFFED(ea)) {
838                 ea->ea_type = GFS2_EATYPE_UNUSED;
839                 return;
840         } else if (GFS2_EA2NEXT(prev) != ea) {
841                 prev = GFS2_EA2NEXT(prev);
842                 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
843         }
844
845         len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
846         prev->ea_rec_len = cpu_to_be32(len);
847
848         if (GFS2_EA_IS_LAST(ea))
849                 prev->ea_flags |= GFS2_EAFLAG_LAST;
850 }
851
852 struct ea_set {
853         int ea_split;
854
855         struct gfs2_ea_request *es_er;
856         struct gfs2_ea_location *es_el;
857
858         struct buffer_head *es_bh;
859         struct gfs2_ea_header *es_ea;
860 };
861
862 static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh,
863                                  struct gfs2_ea_header *ea, struct ea_set *es)
864 {
865         struct gfs2_ea_request *er = es->es_er;
866         struct buffer_head *dibh;
867         int error;
868
869         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
870         if (error)
871                 return error;
872
873         gfs2_trans_add_bh(ip->i_gl, bh, 1);
874
875         if (es->ea_split)
876                 ea = ea_split_ea(ea);
877
878         ea_write(ip, ea, er);
879
880         if (es->es_el)
881                 ea_set_remove_stuffed(ip, es->es_el);
882
883         error = gfs2_meta_inode_buffer(ip, &dibh);
884         if (error)
885                 goto out;
886         ip->i_inode.i_ctime = CURRENT_TIME;
887         gfs2_trans_add_bh(ip->i_gl, dibh, 1);
888         gfs2_dinode_out(ip, dibh->b_data);
889         brelse(dibh);
890 out:
891         gfs2_trans_end(GFS2_SB(&ip->i_inode));
892         return error;
893 }
894
895 static int ea_set_simple_alloc(struct gfs2_inode *ip,
896                                struct gfs2_ea_request *er, void *private)
897 {
898         struct ea_set *es = private;
899         struct gfs2_ea_header *ea = es->es_ea;
900         int error;
901
902         gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
903
904         if (es->ea_split)
905                 ea = ea_split_ea(ea);
906
907         error = ea_write(ip, ea, er);
908         if (error)
909                 return error;
910
911         if (es->es_el)
912                 ea_set_remove_stuffed(ip, es->es_el);
913
914         return 0;
915 }
916
917 static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh,
918                          struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
919                          void *private)
920 {
921         struct ea_set *es = private;
922         unsigned int size;
923         int stuffed;
924         int error;
925
926         stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,
927                                es->es_er->er_data_len, &size);
928
929         if (ea->ea_type == GFS2_EATYPE_UNUSED) {
930                 if (GFS2_EA_REC_LEN(ea) < size)
931                         return 0;
932                 if (!GFS2_EA_IS_STUFFED(ea)) {
933                         error = ea_remove_unstuffed(ip, bh, ea, prev, 1);
934                         if (error)
935                                 return error;
936                 }
937                 es->ea_split = 0;
938         } else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)
939                 es->ea_split = 1;
940         else
941                 return 0;
942
943         if (stuffed) {
944                 error = ea_set_simple_noalloc(ip, bh, ea, es);
945                 if (error)
946                         return error;
947         } else {
948                 unsigned int blks;
949
950                 es->es_bh = bh;
951                 es->es_ea = ea;
952                 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
953                                         GFS2_SB(&ip->i_inode)->sd_jbsize);
954
955                 error = ea_alloc_skeleton(ip, es->es_er, blks,
956                                           ea_set_simple_alloc, es);
957                 if (error)
958                         return error;
959         }
960
961         return 1;
962 }
963
964 static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
965                         void *private)
966 {
967         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
968         struct buffer_head *indbh, *newbh;
969         __be64 *eablk;
970         int error;
971         int mh_size = sizeof(struct gfs2_meta_header);
972
973         if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
974                 __be64 *end;
975
976                 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
977                                        &indbh);
978                 if (error)
979                         return error;
980
981                 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
982                         error = -EIO;
983                         goto out;
984                 }
985
986                 eablk = (__be64 *)(indbh->b_data + mh_size);
987                 end = eablk + sdp->sd_inptrs;
988
989                 for (; eablk < end; eablk++)
990                         if (!*eablk)
991                                 break;
992
993                 if (eablk == end) {
994                         error = -ENOSPC;
995                         goto out;
996                 }
997
998                 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
999         } else {
1000                 u64 blk;
1001                 unsigned int n = 1;
1002                 error = gfs2_alloc_block(ip, &blk, &n);
1003                 if (error)
1004                         return error;
1005                 gfs2_trans_add_unrevoke(sdp, blk, 1);
1006                 indbh = gfs2_meta_new(ip->i_gl, blk);
1007                 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1008                 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
1009                 gfs2_buffer_clear_tail(indbh, mh_size);
1010
1011                 eablk = (__be64 *)(indbh->b_data + mh_size);
1012                 *eablk = cpu_to_be64(ip->i_eattr);
1013                 ip->i_eattr = blk;
1014                 ip->i_diskflags |= GFS2_DIF_EA_INDIRECT;
1015                 gfs2_add_inode_blocks(&ip->i_inode, 1);
1016
1017                 eablk++;
1018         }
1019
1020         error = ea_alloc_blk(ip, &newbh);
1021         if (error)
1022                 goto out;
1023
1024         *eablk = cpu_to_be64((u64)newbh->b_blocknr);
1025         error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
1026         brelse(newbh);
1027         if (error)
1028                 goto out;
1029
1030         if (private)
1031                 ea_set_remove_stuffed(ip, private);
1032
1033 out:
1034         brelse(indbh);
1035         return error;
1036 }
1037
1038 static int ea_set_i(struct gfs2_inode *ip, int type, const char *name,
1039                     const void *value, size_t size, struct gfs2_ea_location *el)
1040 {
1041         struct gfs2_ea_request er;
1042         struct ea_set es;
1043         unsigned int blks = 2;
1044         int error;
1045
1046         er.er_type = type;
1047         er.er_name = name;
1048         er.er_data = (void *)value;
1049         er.er_name_len = strlen(name);
1050         er.er_data_len = size;
1051
1052         memset(&es, 0, sizeof(struct ea_set));
1053         es.es_er = &er;
1054         es.es_el = el;
1055
1056         error = ea_foreach(ip, ea_set_simple, &es);
1057         if (error > 0)
1058                 return 0;
1059         if (error)
1060                 return error;
1061
1062         if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
1063                 blks++;
1064         if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize)
1065                 blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);
1066
1067         return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el);
1068 }
1069
1070 static int ea_set_remove_unstuffed(struct gfs2_inode *ip,
1071                                    struct gfs2_ea_location *el)
1072 {
1073         if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {
1074                 el->el_prev = GFS2_EA2NEXT(el->el_prev);
1075                 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
1076                                      GFS2_EA2NEXT(el->el_prev) == el->el_ea);
1077         }
1078
1079         return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev, 0);
1080 }
1081
1082 static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el)
1083 {
1084         struct gfs2_ea_header *ea = el->el_ea;
1085         struct gfs2_ea_header *prev = el->el_prev;
1086         struct buffer_head *dibh;
1087         int error;
1088
1089         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1090         if (error)
1091                 return error;
1092
1093         gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
1094
1095         if (prev) {
1096                 u32 len;
1097
1098                 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
1099                 prev->ea_rec_len = cpu_to_be32(len);
1100
1101                 if (GFS2_EA_IS_LAST(ea))
1102                         prev->ea_flags |= GFS2_EAFLAG_LAST;
1103         } else {
1104                 ea->ea_type = GFS2_EATYPE_UNUSED;
1105         }
1106
1107         error = gfs2_meta_inode_buffer(ip, &dibh);
1108         if (!error) {
1109                 ip->i_inode.i_ctime = CURRENT_TIME;
1110                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1111                 gfs2_dinode_out(ip, dibh->b_data);
1112                 brelse(dibh);
1113         }
1114
1115         gfs2_trans_end(GFS2_SB(&ip->i_inode));
1116
1117         return error;
1118 }
1119
1120 /**
1121  * gfs2_xattr_remove - Remove a GFS2 extended attribute
1122  * @inode: The inode
1123  * @type: The type of the extended attribute
1124  * @name: The name of the extended attribute
1125  *
1126  * This is not called directly by the VFS since we use the (common)
1127  * scheme of making a "set with NULL data" mean a remove request. Note
1128  * that this is different from a set with zero length data.
1129  *
1130  * Returns: 0, or errno on failure
1131  */
1132
1133 static int gfs2_xattr_remove(struct inode *inode, int type, const char *name)
1134 {
1135         struct gfs2_inode *ip = GFS2_I(inode);
1136         struct gfs2_ea_location el;
1137         int error;
1138
1139         if (!ip->i_eattr)
1140                 return -ENODATA;
1141
1142         error = gfs2_ea_find(ip, type, name, &el);
1143         if (error)
1144                 return error;
1145         if (!el.el_ea)
1146                 return -ENODATA;
1147
1148         if (GFS2_EA_IS_STUFFED(el.el_ea))
1149                 error = ea_remove_stuffed(ip, &el);
1150         else
1151                 error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0);
1152
1153         brelse(el.el_bh);
1154
1155         return error;
1156 }
1157
1158 /**
1159  * gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1160  * @inode: The inode
1161  * @type: The type of the extended attribute
1162  * @name: The name of the extended attribute
1163  * @value: The value of the extended attribute (NULL for remove)
1164  * @size: The size of the @value argument
1165  * @flags: Create or Replace
1166  *
1167  * See gfs2_xattr_remove() for details of the removal of xattrs.
1168  *
1169  * Returns: 0 or errno on failure
1170  */
1171
1172 int gfs2_xattr_set(struct inode *inode, int type, const char *name,
1173                    const void *value, size_t size, int flags)
1174 {
1175         struct gfs2_sbd *sdp = GFS2_SB(inode);
1176         struct gfs2_inode *ip = GFS2_I(inode);
1177         struct gfs2_ea_location el;
1178         unsigned int namel = strlen(name);
1179         int error;
1180
1181         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1182                 return -EPERM;
1183         if (namel > GFS2_EA_MAX_NAME_LEN)
1184                 return -ERANGE;
1185
1186         if (value == NULL)
1187                 return gfs2_xattr_remove(inode, type, name);
1188
1189         if (ea_check_size(sdp, namel, size))
1190                 return -ERANGE;
1191
1192         if (!ip->i_eattr) {
1193                 if (flags & XATTR_REPLACE)
1194                         return -ENODATA;
1195                 return ea_init(ip, type, name, value, size);
1196         }
1197
1198         error = gfs2_ea_find(ip, type, name, &el);
1199         if (error)
1200                 return error;
1201
1202         if (el.el_ea) {
1203                 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
1204                         brelse(el.el_bh);
1205                         return -EPERM;
1206                 }
1207
1208                 error = -EEXIST;
1209                 if (!(flags & XATTR_CREATE)) {
1210                         int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);
1211                         error = ea_set_i(ip, type, name, value, size, &el);
1212                         if (!error && unstuffed)
1213                                 ea_set_remove_unstuffed(ip, &el);
1214                 }
1215
1216                 brelse(el.el_bh);
1217                 return error;
1218         }
1219
1220         error = -ENODATA;
1221         if (!(flags & XATTR_REPLACE))
1222                 error = ea_set_i(ip, type, name, value, size, NULL);
1223
1224         return error;
1225 }
1226
1227 static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1228                                   struct gfs2_ea_header *ea, char *data)
1229 {
1230         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1231         struct buffer_head **bh;
1232         unsigned int amount = GFS2_EA_DATA_LEN(ea);
1233         unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
1234         __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
1235         unsigned int x;
1236         int error;
1237
1238         bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
1239         if (!bh)
1240                 return -ENOMEM;
1241
1242         error = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0);
1243         if (error)
1244                 goto out;
1245
1246         for (x = 0; x < nptrs; x++) {
1247                 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
1248                                        bh + x);
1249                 if (error) {
1250                         while (x--)
1251                                 brelse(bh[x]);
1252                         goto fail;
1253                 }
1254                 dataptrs++;
1255         }
1256
1257         for (x = 0; x < nptrs; x++) {
1258                 error = gfs2_meta_wait(sdp, bh[x]);
1259                 if (error) {
1260                         for (; x < nptrs; x++)
1261                                 brelse(bh[x]);
1262                         goto fail;
1263                 }
1264                 if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {
1265                         for (; x < nptrs; x++)
1266                                 brelse(bh[x]);
1267                         error = -EIO;
1268                         goto fail;
1269                 }
1270
1271                 gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
1272
1273                 memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data,
1274                        (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize);
1275
1276                 amount -= sdp->sd_jbsize;
1277                 data += sdp->sd_jbsize;
1278
1279                 brelse(bh[x]);
1280         }
1281
1282 out:
1283         kfree(bh);
1284         return error;
1285
1286 fail:
1287         gfs2_trans_end(sdp);
1288         kfree(bh);
1289         return error;
1290 }
1291
1292 int gfs2_xattr_acl_chmod(struct gfs2_inode *ip, struct iattr *attr, char *data)
1293 {
1294         struct gfs2_ea_location el;
1295         struct buffer_head *dibh;
1296         int error;
1297
1298         error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, GFS2_POSIX_ACL_ACCESS, &el);
1299         if (error)
1300                 return error;
1301
1302         if (GFS2_EA_IS_STUFFED(el.el_ea)) {
1303                 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1304                 if (error)
1305                         return error;
1306
1307                 gfs2_trans_add_bh(ip->i_gl, el.el_bh, 1);
1308                 memcpy(GFS2_EA2DATA(el.el_ea), data,
1309                        GFS2_EA_DATA_LEN(el.el_ea));
1310         } else
1311                 error = ea_acl_chmod_unstuffed(ip, el.el_ea, data);
1312
1313         if (error)
1314                 return error;
1315
1316         error = gfs2_meta_inode_buffer(ip, &dibh);
1317         if (!error) {
1318                 error = inode_setattr(&ip->i_inode, attr);
1319                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
1320                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1321                 gfs2_dinode_out(ip, dibh->b_data);
1322                 brelse(dibh);
1323         }
1324
1325         gfs2_trans_end(GFS2_SB(&ip->i_inode));
1326
1327         return error;
1328 }
1329
1330 static int ea_dealloc_indirect(struct gfs2_inode *ip)
1331 {
1332         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1333         struct gfs2_rgrp_list rlist;
1334         struct buffer_head *indbh, *dibh;
1335         __be64 *eablk, *end;
1336         unsigned int rg_blocks = 0;
1337         u64 bstart = 0;
1338         unsigned int blen = 0;
1339         unsigned int blks = 0;
1340         unsigned int x;
1341         int error;
1342
1343         memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1344
1345         error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
1346         if (error)
1347                 return error;
1348
1349         if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1350                 error = -EIO;
1351                 goto out;
1352         }
1353
1354         eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1355         end = eablk + sdp->sd_inptrs;
1356
1357         for (; eablk < end; eablk++) {
1358                 u64 bn;
1359
1360                 if (!*eablk)
1361                         break;
1362                 bn = be64_to_cpu(*eablk);
1363
1364                 if (bstart + blen == bn)
1365                         blen++;
1366                 else {
1367                         if (bstart)
1368                                 gfs2_rlist_add(sdp, &rlist, bstart);
1369                         bstart = bn;
1370                         blen = 1;
1371                 }
1372                 blks++;
1373         }
1374         if (bstart)
1375                 gfs2_rlist_add(sdp, &rlist, bstart);
1376         else
1377                 goto out;
1378
1379         gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
1380
1381         for (x = 0; x < rlist.rl_rgrps; x++) {
1382                 struct gfs2_rgrpd *rgd;
1383                 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1384                 rg_blocks += rgd->rd_length;
1385         }
1386
1387         error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1388         if (error)
1389                 goto out_rlist_free;
1390
1391         error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1392                                  RES_STATFS + RES_QUOTA, blks);
1393         if (error)
1394                 goto out_gunlock;
1395
1396         gfs2_trans_add_bh(ip->i_gl, indbh, 1);
1397
1398         eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1399         bstart = 0;
1400         blen = 0;
1401
1402         for (; eablk < end; eablk++) {
1403                 u64 bn;
1404
1405                 if (!*eablk)
1406                         break;
1407                 bn = be64_to_cpu(*eablk);
1408
1409                 if (bstart + blen == bn)
1410                         blen++;
1411                 else {
1412                         if (bstart)
1413                                 gfs2_free_meta(ip, bstart, blen);
1414                         bstart = bn;
1415                         blen = 1;
1416                 }
1417
1418                 *eablk = 0;
1419                 gfs2_add_inode_blocks(&ip->i_inode, -1);
1420         }
1421         if (bstart)
1422                 gfs2_free_meta(ip, bstart, blen);
1423
1424         ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
1425
1426         error = gfs2_meta_inode_buffer(ip, &dibh);
1427         if (!error) {
1428                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1429                 gfs2_dinode_out(ip, dibh->b_data);
1430                 brelse(dibh);
1431         }
1432
1433         gfs2_trans_end(sdp);
1434
1435 out_gunlock:
1436         gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1437 out_rlist_free:
1438         gfs2_rlist_free(&rlist);
1439 out:
1440         brelse(indbh);
1441         return error;
1442 }
1443
1444 static int ea_dealloc_block(struct gfs2_inode *ip)
1445 {
1446         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1447         struct gfs2_alloc *al = ip->i_alloc;
1448         struct gfs2_rgrpd *rgd;
1449         struct buffer_head *dibh;
1450         int error;
1451
1452         rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr);
1453         if (!rgd) {
1454                 gfs2_consist_inode(ip);
1455                 return -EIO;
1456         }
1457
1458         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0,
1459                                    &al->al_rgd_gh);
1460         if (error)
1461                 return error;
1462
1463         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1464                                  RES_QUOTA, 1);
1465         if (error)
1466                 goto out_gunlock;
1467
1468         gfs2_free_meta(ip, ip->i_eattr, 1);
1469
1470         ip->i_eattr = 0;
1471         gfs2_add_inode_blocks(&ip->i_inode, -1);
1472
1473         error = gfs2_meta_inode_buffer(ip, &dibh);
1474         if (!error) {
1475                 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
1476                 gfs2_dinode_out(ip, dibh->b_data);
1477                 brelse(dibh);
1478         }
1479
1480         gfs2_trans_end(sdp);
1481
1482 out_gunlock:
1483         gfs2_glock_dq_uninit(&al->al_rgd_gh);
1484         return error;
1485 }
1486
1487 /**
1488  * gfs2_ea_dealloc - deallocate the extended attribute fork
1489  * @ip: the inode
1490  *
1491  * Returns: errno
1492  */
1493
1494 int gfs2_ea_dealloc(struct gfs2_inode *ip)
1495 {
1496         struct gfs2_alloc *al;
1497         int error;
1498
1499         al = gfs2_alloc_get(ip);
1500         if (!al)
1501                 return -ENOMEM;
1502
1503         error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1504         if (error)
1505                 goto out_alloc;
1506
1507         error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh);
1508         if (error)
1509                 goto out_quota;
1510
1511         error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1512         if (error)
1513                 goto out_rindex;
1514
1515         if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
1516                 error = ea_dealloc_indirect(ip);
1517                 if (error)
1518                         goto out_rindex;
1519         }
1520
1521         error = ea_dealloc_block(ip);
1522
1523 out_rindex:
1524         gfs2_glock_dq_uninit(&al->al_ri_gh);
1525 out_quota:
1526         gfs2_quota_unhold(ip);
1527 out_alloc:
1528         gfs2_alloc_put(ip);
1529         return error;
1530 }
1531
1532 static int gfs2_xattr_user_get(struct inode *inode, const char *name,
1533                                void *buffer, size_t size)
1534 {
1535         return gfs2_xattr_get(inode, GFS2_EATYPE_USR, name, buffer, size);
1536 }
1537
1538 static int gfs2_xattr_user_set(struct inode *inode, const char *name,
1539                                const void *value, size_t size, int flags)
1540 {
1541         return gfs2_xattr_set(inode, GFS2_EATYPE_USR, name, value, size, flags);
1542 }
1543
1544 static int gfs2_xattr_security_get(struct inode *inode, const char *name,
1545                                    void *buffer, size_t size)
1546 {
1547         return gfs2_xattr_get(inode, GFS2_EATYPE_SECURITY, name, buffer, size);
1548 }
1549
1550 static int gfs2_xattr_security_set(struct inode *inode, const char *name,
1551                                    const void *value, size_t size, int flags)
1552 {
1553         return gfs2_xattr_set(inode, GFS2_EATYPE_SECURITY, name, value, size, flags);
1554 }
1555
1556 static struct xattr_handler gfs2_xattr_user_handler = {
1557         .prefix = XATTR_USER_PREFIX,
1558         .get    = gfs2_xattr_user_get,
1559         .set    = gfs2_xattr_user_set,
1560 };
1561
1562 static struct xattr_handler gfs2_xattr_security_handler = {
1563         .prefix = XATTR_SECURITY_PREFIX,
1564         .get    = gfs2_xattr_security_get,
1565         .set    = gfs2_xattr_security_set,
1566 };
1567
1568 struct xattr_handler *gfs2_xattr_handlers[] = {
1569         &gfs2_xattr_user_handler,
1570         &gfs2_xattr_security_handler,
1571         &gfs2_xattr_system_handler,
1572         NULL,
1573 };
1574