blob: 899763aed217498f827ed7743a4ad04c14f95b57 [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#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>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050015#include <linux/gfs2_ondisk.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000016#include <asm/uaccess.h>
17
18#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000020#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"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050029#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000030
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
41static 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
53static 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
Steven Whitehousecca195c2006-09-05 13:15:18 -040069typedef int (*ea_call_t) (struct gfs2_inode *ip, struct buffer_head *bh,
David Teiglandb3b94fa2006-01-16 16:50:04 +000070 struct gfs2_ea_header *ea,
Steven Whitehousecca195c2006-09-05 13:15:18 -040071 struct gfs2_ea_header *prev, void *private);
David Teiglandb3b94fa2006-01-16 16:50:04 +000072
73static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040079 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA))
David Teiglandb3b94fa2006-01-16 16:50:04 +000080 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;
Steven Whitehousecca195c2006-09-05 13:15:18 -040085 if (!(bh->b_data <= (char *)ea && (char *)GFS2_EA2NEXT(ea) <=
86 bh->b_data + bh->b_size))
David Teiglandb3b94fa2006-01-16 16:50:04 +000087 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
Steven Whitehousea91ea692006-09-04 12:04:26 -0400105fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000106 gfs2_consist_inode(ip);
107 return -EIO;
108}
109
110static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data)
111{
112 struct buffer_head *bh, *eabh;
Al Virob44b84d2006-10-14 10:46:30 -0400113 __be64 *eablk, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000114 int error;
115
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000116 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000117 if (error)
118 return error;
119
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000120 if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000121 error = ea_foreach_i(ip, bh, ea_call, data);
122 goto out;
123 }
124
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400125 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000126 error = -EIO;
127 goto out;
128 }
129
Al Virob44b84d2006-10-14 10:46:30 -0400130 eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header));
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400131 end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000132
133 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -0400134 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000135
136 if (!*eablk)
137 break;
138 bn = be64_to_cpu(*eablk);
139
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400140 error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000141 if (error)
142 break;
143 error = ea_foreach_i(ip, eabh, ea_call, data);
144 brelse(eabh);
145 if (error)
146 break;
147 }
Steven Whitehousea91ea692006-09-04 12:04:26 -0400148out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000149 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000150 return error;
151}
152
153struct ea_find {
154 struct gfs2_ea_request *ef_er;
155 struct gfs2_ea_location *ef_el;
156};
157
158static 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
David Teiglandb3b94fa2006-01-16 16:50:04 +0000180 return 0;
181}
182
183int 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
216static 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;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400221 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000222 struct gfs2_rgrpd *rgd;
223 struct gfs2_holder rg_gh;
224 struct buffer_head *dibh;
Al Virob44b84d2006-10-14 10:46:30 -0400225 __be64 *dataptrs;
226 u64 bn = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -0400227 u64 bstart = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000228 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);
Steven Whitehousecca195c2006-09-05 13:15:18 -0400237 for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000238 if (*dataptrs) {
239 blks++;
240 bn = be64_to_cpu(*dataptrs);
241 }
Steven Whitehousecca195c2006-09-05 13:15:18 -0400242 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000243 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
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100256 error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE +
Steven Whitehousecca195c2006-09-05 13:15:18 -0400257 RES_EATTR + RES_STATFS + RES_QUOTA, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000258 if (error)
259 goto out_gunlock;
260
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000261 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000262
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;
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000279 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000280 }
281 if (bstart)
282 gfs2_free_meta(ip, bstart, blen);
283
284 if (prev && !leave) {
Steven Whitehousecd915492006-09-04 12:49:07 -0400285 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000286
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) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100299 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000300 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500301 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000302 brelse(dibh);
303 }
304
305 gfs2_trans_end(sdp);
306
Steven Whitehousea91ea692006-09-04 12:04:26 -0400307out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000308 gfs2_glock_dq_uninit(&rg_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000309 return error;
310}
311
312static 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);
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +0300320 if (!al)
321 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000322
323 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
324 if (error)
325 goto out_alloc;
326
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400327 error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000328 if (error)
329 goto out_quota;
330
Steven Whitehousecca195c2006-09-05 13:15:18 -0400331 error = ea_dealloc_unstuffed(ip, bh, ea, prev, (leave) ? &error : NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000332
333 gfs2_glock_dq_uninit(&al->al_ri_gh);
334
Steven Whitehousea91ea692006-09-04 12:04:26 -0400335out_quota:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000336 gfs2_quota_unhold(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400337out_alloc:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000338 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000339 return error;
340}
341
David Teiglandb3b94fa2006-01-16 16:50:04 +0000342struct ea_list {
343 struct gfs2_ea_request *ei_er;
344 unsigned int ei_size;
345};
346
347static 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;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400353 unsigned int ea_size = gfs2_ea_strlen(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000354
355 if (ea->ea_type == GFS2_EATYPE_UNUSED)
356 return 0;
357
358 if (er->er_data_len) {
Steven Whitehouse01eb7c02006-06-06 17:31:30 -0400359 char *prefix = NULL;
360 unsigned int l = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000361 char c = 0;
362
363 if (ei->ei_size + ea_size > er->er_data_len)
364 return -ERANGE;
365
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400366 switch (ea->ea_type) {
367 case GFS2_EATYPE_USR:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000368 prefix = "user.";
369 l = 5;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400370 break;
371 case GFS2_EATYPE_SYS:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000372 prefix = "system.";
373 l = 7;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400374 break;
375 case GFS2_EATYPE_SECURITY:
376 prefix = "security.";
377 l = 9;
378 break;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000379 }
380
Steven Whitehouse01eb7c02006-06-06 17:31:30 -0400381 BUG_ON(l == 0);
382
Steven Whitehouse90cdd202006-05-22 10:36:25 -0400383 memcpy(er->er_data + ei->ei_size, prefix, l);
384 memcpy(er->er_data + ei->ei_size + l, GFS2_EA2NAME(ea),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000385 ea->ea_name_len);
Steven Whitehouse90cdd202006-05-22 10:36:25 -0400386 memcpy(er->er_data + ei->ei_size + ea_size - 1, &c, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000387 }
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
402int 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400412 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000413 if (error)
414 return error;
415
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000416 if (ip->i_eattr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000417 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400432 * @ip: The GFS2 inode
433 * @ea: The extended attribute header structure
434 * @data: The data to be copied
David Teiglandb3b94fa2006-01-16 16:50:04 +0000435 *
436 * Returns: errno
437 */
438
439static int ea_get_unstuffed(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
440 char *data)
441{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400442 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000443 struct buffer_head **bh;
444 unsigned int amount = GFS2_EA_DATA_LEN(ea);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500445 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
Al Virob44b84d2006-10-14 10:46:30 -0400446 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000447 unsigned int x;
448 int error = 0;
449
Josef Bacik16c5f062008-04-09 09:33:41 -0400450 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000451 if (!bh)
452 return -ENOMEM;
453
454 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400455 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
456 bh + x);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000457 if (error) {
458 while (x--)
459 brelse(bh[x]);
460 goto out;
461 }
462 dataptrs++;
463 }
464
465 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400466 error = gfs2_meta_wait(sdp, bh[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000467 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400479 memcpy(data, bh[x]->b_data + sizeof(struct gfs2_meta_header),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000480 (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
Steven Whitehousea91ea692006-09-04 12:04:26 -0400488out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000490 return error;
491}
492
493int 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)) {
Steven Whitehousecca195c2006-09-05 13:15:18 -0400497 memcpy(data, GFS2_EA2DATA(el->el_ea), GFS2_EA_DATA_LEN(el->el_ea));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000498 return 0;
499 } else
500 return ea_get_unstuffed(ip, el->el_ea, data);
501}
502
503/**
504 * gfs2_ea_get_i -
Steven Whitehousecca195c2006-09-05 13:15:18 -0400505 * @ip: The GFS2 inode
506 * @er: The request structure
David Teiglandb3b94fa2006-01-16 16:50:04 +0000507 *
508 * Returns: actual size of data on success, -errno on error
509 */
510
511int gfs2_ea_get_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
512{
513 struct gfs2_ea_location el;
514 int error;
515
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000516 if (!ip->i_eattr)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000517 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 -
Steven Whitehousecca195c2006-09-05 13:15:18 -0400541 * @ip: The GFS2 inode
542 * @er: The request structure
David Teiglandb3b94fa2006-01-16 16:50:04 +0000543 *
544 * Returns: actual size of data on success, -errno on error
545 */
546
547int 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400560 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400574 * @bhp: Pointer to pointer to a struct buffer_head
David Teiglandb3b94fa2006-01-16 16:50:04 +0000575 *
576 * Returns: errno
577 */
578
579static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp)
580{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400581 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000582 struct gfs2_ea_header *ea;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000583 unsigned int n = 1;
Steven Whitehousecd915492006-09-04 12:49:07 -0400584 u64 block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000585
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000586 block = gfs2_alloc_block(ip, &n);
Steven Whitehouse5731be52008-02-01 13:16:55 +0000587 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000588 *bhp = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000589 gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000590 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
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000599 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000600
601 return 0;
602}
603
604/**
605 * ea_write - writes the request info to an ea, creating new blocks if
606 * necessary
Steven Whitehousecca195c2006-09-05 13:15:18 -0400607 * @ip: inode that is being modified
608 * @ea: the location of the new ea in a block
David Teiglandb3b94fa2006-01-16 16:50:04 +0000609 * @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
616static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
617 struct gfs2_ea_request *er)
618{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400619 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000620
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 {
Al Virob44b84d2006-10-14 10:46:30 -0400632 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000633 const char *data = er->er_data;
634 unsigned int data_len = er->er_data_len;
635 unsigned int copy;
636 unsigned int x;
637
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500638 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000639 for (x = 0; x < ea->ea_num_ptrs; x++) {
640 struct buffer_head *bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400641 u64 block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000642 int mh_size = sizeof(struct gfs2_meta_header);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000643 unsigned int n = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000644
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000645 block = gfs2_alloc_block(ip, &n);
Steven Whitehouse5731be52008-02-01 13:16:55 +0000646 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000647 bh = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000648 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000649 gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
650
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000651 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000652
Steven Whitehousecca195c2006-09-05 13:15:18 -0400653 copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
654 data_len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000655 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400660 *dataptr++ = cpu_to_be64(bh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000661 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
673typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400674 struct gfs2_ea_request *er, void *private);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000675
676static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
677 unsigned int blks,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400678 ea_skeleton_call_t skeleton_call, void *private)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000679{
680 struct gfs2_alloc *al;
681 struct buffer_head *dibh;
682 int error;
683
684 al = gfs2_alloc_get(ip);
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +0300685 if (!al)
686 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000687
Steven Whitehoused82661d2008-03-10 15:34:50 +0000688 error = gfs2_quota_lock_check(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000689 if (error)
690 goto out;
691
David Teiglandb3b94fa2006-01-16 16:50:04 +0000692 al->al_requested = blks;
693
694 error = gfs2_inplace_reserve(ip);
695 if (error)
696 goto out_gunlock_q;
697
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400698 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100699 blks + al->al_rgd->rd_length +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000700 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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400711 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500712 (ip->i_inode.i_mode & S_IFMT) ==
David Teiglandb3b94fa2006-01-16 16:50:04 +0000713 (er->er_mode & S_IFMT));
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500714 ip->i_inode.i_mode = er->er_mode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000715 }
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100716 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000717 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500718 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000719 brelse(dibh);
720 }
721
Steven Whitehousea91ea692006-09-04 12:04:26 -0400722out_end_trans:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400723 gfs2_trans_end(GFS2_SB(&ip->i_inode));
Steven Whitehousea91ea692006-09-04 12:04:26 -0400724out_ipres:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000725 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400726out_gunlock_q:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000727 gfs2_quota_unlock(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400728out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000729 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000730 return error;
731}
732
733static 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
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000743 ip->i_eattr = bh->b_blocknr;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000744 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
759static int ea_init(struct gfs2_inode *ip, struct gfs2_ea_request *er)
760{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400761 unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000762 unsigned int blks = 1;
763
764 if (GFS2_EAREQ_SIZE_STUFFED(er) > jbsize)
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500765 blks += DIV_ROUND_UP(er->er_data_len, jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000766
767 return ea_alloc_skeleton(ip, er, blks, ea_init_i, NULL);
768}
769
770static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
771{
Steven Whitehousecd915492006-09-04 12:49:07 -0400772 u32 ea_size = GFS2_EA_SIZE(ea);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500773 struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
774 ea_size);
Steven Whitehousecd915492006-09-04 12:49:07 -0400775 u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000776 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
787static 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;
Steven Whitehousecd915492006-09-04 12:49:07 -0400792 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000793
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000794 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000795
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);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400801 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000802 }
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
811struct 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
821static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400828 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000829 if (error)
830 return error;
831
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000832 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000833
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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400847 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500848 (ip->i_inode.i_mode & S_IFMT) == (er->er_mode & S_IFMT));
849 ip->i_inode.i_mode = er->er_mode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000850 }
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100851 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000852 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500853 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000854 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400855out:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400856 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000857 return error;
858}
859
860static 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000867 gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000868
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
882static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400891 stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er, &size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000892
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;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500916 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400917 GFS2_SB(&ip->i_inode)->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000918
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
928static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
929 void *private)
930{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400931 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000932 struct buffer_head *indbh, *newbh;
Al Virob44b84d2006-10-14 10:46:30 -0400933 __be64 *eablk;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000934 int error;
935 int mh_size = sizeof(struct gfs2_meta_header);
936
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000937 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
Al Virob44b84d2006-10-14 10:46:30 -0400938 __be64 *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000939
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000940 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400941 &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000942 if (error)
943 return error;
944
945 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
946 error = -EIO;
947 goto out;
948 }
949
Al Virob44b84d2006-10-14 10:46:30 -0400950 eablk = (__be64 *)(indbh->b_data + mh_size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000951 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000962 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000963 } else {
Steven Whitehousecd915492006-09-04 12:49:07 -0400964 u64 blk;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000965 unsigned int n = 1;
966 blk = gfs2_alloc_block(ip, &n);
Steven Whitehouse5731be52008-02-01 13:16:55 +0000967 gfs2_trans_add_unrevoke(sdp, blk, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000968 indbh = gfs2_meta_new(ip->i_gl, blk);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000969 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000970 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
971 gfs2_buffer_clear_tail(indbh, mh_size);
972
Al Virob44b84d2006-10-14 10:46:30 -0400973 eablk = (__be64 *)(indbh->b_data + mh_size);
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000974 *eablk = cpu_to_be64(ip->i_eattr);
975 ip->i_eattr = blk;
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000976 ip->i_diskflags |= GFS2_DIF_EA_INDIRECT;
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000977 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000978
979 eablk++;
980 }
981
982 error = ea_alloc_blk(ip, &newbh);
983 if (error)
984 goto out;
985
Steven Whitehousecd915492006-09-04 12:49:07 -0400986 *eablk = cpu_to_be64((u64)newbh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000987 error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
988 brelse(newbh);
989 if (error)
990 goto out;
991
992 if (private)
Steven Whitehousecca195c2006-09-05 13:15:18 -0400993 ea_set_remove_stuffed(ip, private);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000994
Steven Whitehousea91ea692006-09-04 12:04:26 -0400995out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000996 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000997 return error;
998}
999
1000static 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
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001017 if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001018 blks++;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001019 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);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001021
1022 return ea_alloc_skeleton(ip, er, blks, ea_set_block, el);
1023}
1024
1025static 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);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001030 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
David Teiglandb3b94fa2006-01-16 16:50:04 +00001031 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
1037int gfs2_ea_set_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1038{
1039 struct gfs2_ea_location el;
1040 int error;
1041
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001042 if (!ip->i_eattr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001043 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) {
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001053 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001054 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
1076int gfs2_ea_set(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1077{
1078 struct gfs2_holder i_gh;
1079 int error;
1080
Steven Whitehousecca195c2006-09-05 13:15:18 -04001081 if (!er->er_name_len || er->er_name_len > GFS2_EA_MAX_NAME_LEN)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001082 return -EINVAL;
1083 if (!er->er_data || !er->er_data_len) {
1084 er->er_data = NULL;
1085 er->er_data_len = 0;
1086 }
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001087 error = ea_check_size(GFS2_SB(&ip->i_inode), er);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001088 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001095 if (IS_IMMUTABLE(&ip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001096 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
1105static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001112 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001113 if (error)
1114 return error;
1115
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001116 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001117
1118 if (prev) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001119 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001120
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) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +01001131 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001132 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001133 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001134 brelse(dibh);
Steven Whitehouse907b9bc2006-09-25 09:26:04 -04001135 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001136
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001137 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001138
1139 return error;
1140}
1141
1142int gfs2_ea_remove_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1143{
1144 struct gfs2_ea_location el;
1145 int error;
1146
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001147 if (!ip->i_eattr)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001148 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
1175int 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001187 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001188 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
1197static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1198 struct gfs2_ea_header *ea, char *data)
1199{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001200 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001201 struct buffer_head **bh;
1202 unsigned int amount = GFS2_EA_DATA_LEN(ea);
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001203 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
Al Virob44b84d2006-10-14 10:46:30 -04001204 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001205 unsigned int x;
1206 int error;
1207
Josef Bacik16c5f062008-04-09 09:33:41 -04001208 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001209 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++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001217 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
1218 bh + x);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001219 if (error) {
1220 while (x--)
1221 brelse(bh[x]);
1222 goto fail;
1223 }
1224 dataptrs++;
1225 }
1226
1227 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001228 error = gfs2_meta_wait(sdp, bh[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001229 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001241 gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001242
Steven Whitehousecca195c2006-09-05 13:15:18 -04001243 memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001244 (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
Steven Whitehousea91ea692006-09-04 12:04:26 -04001252out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001253 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001254 return error;
1255
Steven Whitehousea91ea692006-09-04 12:04:26 -04001256fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001257 gfs2_trans_end(sdp);
1258 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001259 return error;
1260}
1261
1262int 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)) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001269 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001270 if (error)
1271 return error;
1272
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001273 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
Steven Whitehousecca195c2006-09-05 13:15:18 -04001274 memcpy(GFS2_EA2DATA(el->el_ea), data,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001275 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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001284 error = inode_setattr(&ip->i_inode, attr);
1285 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001286 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001287 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001288 brelse(dibh);
1289 }
1290
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001291 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001292
1293 return error;
1294}
1295
1296static int ea_dealloc_indirect(struct gfs2_inode *ip)
1297{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001298 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001299 struct gfs2_rgrp_list rlist;
1300 struct buffer_head *indbh, *dibh;
Al Virob44b84d2006-10-14 10:46:30 -04001301 __be64 *eablk, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001302 unsigned int rg_blocks = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -04001303 u64 bstart = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001304 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
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001311 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001312 if (error)
1313 return error;
1314
1315 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1316 error = -EIO;
1317 goto out;
1318 }
1319
Al Virob44b84d2006-10-14 10:46:30 -04001320 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001321 end = eablk + sdp->sd_inptrs;
1322
1323 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001324 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001325
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
Bob Petersonfe6c9912008-01-28 11:13:02 -06001345 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001346
1347 for (x = 0; x < rlist.rl_rgrps; x++) {
1348 struct gfs2_rgrpd *rgd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001349 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001350 rg_blocks += rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001351 }
1352
1353 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1354 if (error)
1355 goto out_rlist_free;
1356
Steven Whitehousecca195c2006-09-05 13:15:18 -04001357 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1358 RES_STATFS + RES_QUOTA, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001359 if (error)
1360 goto out_gunlock;
1361
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001362 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001363
Al Virob44b84d2006-10-14 10:46:30 -04001364 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001365 bstart = 0;
1366 blen = 0;
1367
1368 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001369 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001370
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;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001385 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001386 }
1387 if (bstart)
1388 gfs2_free_meta(ip, bstart, blen);
1389
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001390 ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001391
1392 error = gfs2_meta_inode_buffer(ip, &dibh);
1393 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001394 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001395 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001396 brelse(dibh);
1397 }
1398
1399 gfs2_trans_end(sdp);
1400
Steven Whitehousea91ea692006-09-04 12:04:26 -04001401out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001402 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001403out_rlist_free:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001404 gfs2_rlist_free(&rlist);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001405out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001406 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001407 return error;
1408}
1409
1410static int ea_dealloc_block(struct gfs2_inode *ip)
1411{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001412 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001413 struct gfs2_alloc *al = ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001414 struct gfs2_rgrpd *rgd;
1415 struct buffer_head *dibh;
1416 int error;
1417
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001418 rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001419 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
Steven Whitehousecca195c2006-09-05 13:15:18 -04001429 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1430 RES_QUOTA, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001431 if (error)
1432 goto out_gunlock;
1433
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001434 gfs2_free_meta(ip, ip->i_eattr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001435
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001436 ip->i_eattr = 0;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001437 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001438
1439 error = gfs2_meta_inode_buffer(ip, &dibh);
1440 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001441 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001442 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001443 brelse(dibh);
1444 }
1445
1446 gfs2_trans_end(sdp);
1447
Steven Whitehousea91ea692006-09-04 12:04:26 -04001448out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001449 gfs2_glock_dq_uninit(&al->al_rgd_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001450 return error;
1451}
1452
1453/**
1454 * gfs2_ea_dealloc - deallocate the extended attribute fork
1455 * @ip: the inode
1456 *
1457 * Returns: errno
1458 */
1459
1460int gfs2_ea_dealloc(struct gfs2_inode *ip)
1461{
1462 struct gfs2_alloc *al;
1463 int error;
1464
1465 al = gfs2_alloc_get(ip);
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +03001466 if (!al)
1467 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001468
1469 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1470 if (error)
1471 goto out_alloc;
1472
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001473 error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001474 if (error)
1475 goto out_quota;
1476
1477 error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1478 if (error)
1479 goto out_rindex;
1480
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001481 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001482 error = ea_dealloc_indirect(ip);
1483 if (error)
1484 goto out_rindex;
1485 }
1486
1487 error = ea_dealloc_block(ip);
1488
Steven Whitehousea91ea692006-09-04 12:04:26 -04001489out_rindex:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001490 gfs2_glock_dq_uninit(&al->al_ri_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001491out_quota:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001492 gfs2_quota_unhold(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001493out_alloc:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001494 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001495 return error;
1496}
1497