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