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