blob: 07ea9529adda162830829080dac6c5c98b382103 [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;
Steven Whitehouse09010972009-05-20 10:48:47 +0100585 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000586
Steven Whitehouse09010972009-05-20 10:48:47 +0100587 error = gfs2_alloc_block(ip, &block, &n);
588 if (error)
589 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000590 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000591 *bhp = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000592 gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000593 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
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000602 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000603
604 return 0;
605}
606
607/**
608 * ea_write - writes the request info to an ea, creating new blocks if
609 * necessary
Steven Whitehousecca195c2006-09-05 13:15:18 -0400610 * @ip: inode that is being modified
611 * @ea: the location of the new ea in a block
David Teiglandb3b94fa2006-01-16 16:50:04 +0000612 * @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
619static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
620 struct gfs2_ea_request *er)
621{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400622 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse09010972009-05-20 10:48:47 +0100623 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000624
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 {
Al Virob44b84d2006-10-14 10:46:30 -0400636 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000637 const char *data = er->er_data;
638 unsigned int data_len = er->er_data_len;
639 unsigned int copy;
640 unsigned int x;
641
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500642 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000643 for (x = 0; x < ea->ea_num_ptrs; x++) {
644 struct buffer_head *bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400645 u64 block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000646 int mh_size = sizeof(struct gfs2_meta_header);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000647 unsigned int n = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000648
Steven Whitehouse09010972009-05-20 10:48:47 +0100649 error = gfs2_alloc_block(ip, &block, &n);
650 if (error)
651 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000652 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000653 bh = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000654 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000655 gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
656
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000657 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000658
Steven Whitehousecca195c2006-09-05 13:15:18 -0400659 copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
660 data_len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000661 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
Steven Whitehousecca195c2006-09-05 13:15:18 -0400666 *dataptr++ = cpu_to_be64(bh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000667 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
679typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400680 struct gfs2_ea_request *er, void *private);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000681
682static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
683 unsigned int blks,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400684 ea_skeleton_call_t skeleton_call, void *private)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000685{
686 struct gfs2_alloc *al;
687 struct buffer_head *dibh;
688 int error;
689
690 al = gfs2_alloc_get(ip);
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +0300691 if (!al)
692 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000693
Steven Whitehoused82661d2008-03-10 15:34:50 +0000694 error = gfs2_quota_lock_check(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000695 if (error)
696 goto out;
697
David Teiglandb3b94fa2006-01-16 16:50:04 +0000698 al->al_requested = blks;
699
700 error = gfs2_inplace_reserve(ip);
701 if (error)
702 goto out_gunlock_q;
703
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400704 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100705 blks + al->al_rgd->rd_length +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000706 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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400717 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500718 (ip->i_inode.i_mode & S_IFMT) ==
David Teiglandb3b94fa2006-01-16 16:50:04 +0000719 (er->er_mode & S_IFMT));
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500720 ip->i_inode.i_mode = er->er_mode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000721 }
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100722 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000723 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500724 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000725 brelse(dibh);
726 }
727
Steven Whitehousea91ea692006-09-04 12:04:26 -0400728out_end_trans:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400729 gfs2_trans_end(GFS2_SB(&ip->i_inode));
Steven Whitehousea91ea692006-09-04 12:04:26 -0400730out_ipres:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000731 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400732out_gunlock_q:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000733 gfs2_quota_unlock(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400734out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000735 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000736 return error;
737}
738
739static 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
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000749 ip->i_eattr = bh->b_blocknr;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000750 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
765static int ea_init(struct gfs2_inode *ip, struct gfs2_ea_request *er)
766{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400767 unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000768 unsigned int blks = 1;
769
770 if (GFS2_EAREQ_SIZE_STUFFED(er) > jbsize)
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500771 blks += DIV_ROUND_UP(er->er_data_len, jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000772
773 return ea_alloc_skeleton(ip, er, blks, ea_init_i, NULL);
774}
775
776static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
777{
Steven Whitehousecd915492006-09-04 12:49:07 -0400778 u32 ea_size = GFS2_EA_SIZE(ea);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500779 struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
780 ea_size);
Steven Whitehousecd915492006-09-04 12:49:07 -0400781 u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000782 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
793static 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;
Steven Whitehousecd915492006-09-04 12:49:07 -0400798 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000799
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000800 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000801
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);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400807 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000808 }
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
817struct 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
827static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400834 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000835 if (error)
836 return error;
837
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000838 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000839
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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400853 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500854 (ip->i_inode.i_mode & S_IFMT) == (er->er_mode & S_IFMT));
855 ip->i_inode.i_mode = er->er_mode;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000856 }
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100857 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000858 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500859 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000860 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400861out:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400862 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000863 return error;
864}
865
866static 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000873 gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000874
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
888static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400897 stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er, &size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000898
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;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500922 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400923 GFS2_SB(&ip->i_inode)->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000924
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
934static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
935 void *private)
936{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400937 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000938 struct buffer_head *indbh, *newbh;
Al Virob44b84d2006-10-14 10:46:30 -0400939 __be64 *eablk;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000940 int error;
941 int mh_size = sizeof(struct gfs2_meta_header);
942
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000943 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
Al Virob44b84d2006-10-14 10:46:30 -0400944 __be64 *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000945
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000946 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400947 &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000948 if (error)
949 return error;
950
951 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
952 error = -EIO;
953 goto out;
954 }
955
Al Virob44b84d2006-10-14 10:46:30 -0400956 eablk = (__be64 *)(indbh->b_data + mh_size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000957 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000968 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000969 } else {
Steven Whitehousecd915492006-09-04 12:49:07 -0400970 u64 blk;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000971 unsigned int n = 1;
Steven Whitehouse09010972009-05-20 10:48:47 +0100972 error = gfs2_alloc_block(ip, &blk, &n);
973 if (error)
974 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000975 gfs2_trans_add_unrevoke(sdp, blk, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000976 indbh = gfs2_meta_new(ip->i_gl, blk);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000977 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000978 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
979 gfs2_buffer_clear_tail(indbh, mh_size);
980
Al Virob44b84d2006-10-14 10:46:30 -0400981 eablk = (__be64 *)(indbh->b_data + mh_size);
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000982 *eablk = cpu_to_be64(ip->i_eattr);
983 ip->i_eattr = blk;
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000984 ip->i_diskflags |= GFS2_DIF_EA_INDIRECT;
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000985 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000986
987 eablk++;
988 }
989
990 error = ea_alloc_blk(ip, &newbh);
991 if (error)
992 goto out;
993
Steven Whitehousecd915492006-09-04 12:49:07 -0400994 *eablk = cpu_to_be64((u64)newbh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000995 error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
996 brelse(newbh);
997 if (error)
998 goto out;
999
1000 if (private)
Steven Whitehousecca195c2006-09-05 13:15:18 -04001001 ea_set_remove_stuffed(ip, private);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001002
Steven Whitehousea91ea692006-09-04 12:04:26 -04001003out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001004 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001005 return error;
1006}
1007
1008static 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
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001025 if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001026 blks++;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001027 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);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001029
1030 return ea_alloc_skeleton(ip, er, blks, ea_set_block, el);
1031}
1032
1033static 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);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001038 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
David Teiglandb3b94fa2006-01-16 16:50:04 +00001039 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
1045int gfs2_ea_set_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1046{
1047 struct gfs2_ea_location el;
1048 int error;
1049
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001050 if (!ip->i_eattr) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001051 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) {
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001061 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001062 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
1084int gfs2_ea_set(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1085{
1086 struct gfs2_holder i_gh;
1087 int error;
1088
Steven Whitehousecca195c2006-09-05 13:15:18 -04001089 if (!er->er_name_len || er->er_name_len > GFS2_EA_MAX_NAME_LEN)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001090 return -EINVAL;
1091 if (!er->er_data || !er->er_data_len) {
1092 er->er_data = NULL;
1093 er->er_data_len = 0;
1094 }
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001095 error = ea_check_size(GFS2_SB(&ip->i_inode), er);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001096 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001103 if (IS_IMMUTABLE(&ip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001104 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
1113static 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001120 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001121 if (error)
1122 return error;
1123
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001124 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001125
1126 if (prev) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001127 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001128
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) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +01001139 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001140 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001141 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001142 brelse(dibh);
Steven Whitehouse907b9bc2006-09-25 09:26:04 -04001143 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001144
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001145 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001146
1147 return error;
1148}
1149
1150int gfs2_ea_remove_i(struct gfs2_inode *ip, struct gfs2_ea_request *er)
1151{
1152 struct gfs2_ea_location el;
1153 int error;
1154
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001155 if (!ip->i_eattr)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001156 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
1183int 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
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001195 if (IS_IMMUTABLE(&ip->i_inode) || IS_APPEND(&ip->i_inode))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001196 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
1205static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1206 struct gfs2_ea_header *ea, char *data)
1207{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001208 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001209 struct buffer_head **bh;
1210 unsigned int amount = GFS2_EA_DATA_LEN(ea);
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001211 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
Al Virob44b84d2006-10-14 10:46:30 -04001212 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001213 unsigned int x;
1214 int error;
1215
Josef Bacik16c5f062008-04-09 09:33:41 -04001216 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001217 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++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001225 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
1226 bh + x);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001227 if (error) {
1228 while (x--)
1229 brelse(bh[x]);
1230 goto fail;
1231 }
1232 dataptrs++;
1233 }
1234
1235 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001236 error = gfs2_meta_wait(sdp, bh[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001237 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
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001249 gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001250
Steven Whitehousecca195c2006-09-05 13:15:18 -04001251 memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001252 (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
Steven Whitehousea91ea692006-09-04 12:04:26 -04001260out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001261 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001262 return error;
1263
Steven Whitehousea91ea692006-09-04 12:04:26 -04001264fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001265 gfs2_trans_end(sdp);
1266 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001267 return error;
1268}
1269
1270int 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)) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001277 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001278 if (error)
1279 return error;
1280
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001281 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
Steven Whitehousecca195c2006-09-05 13:15:18 -04001282 memcpy(GFS2_EA2DATA(el->el_ea), data,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001283 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) {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001292 error = inode_setattr(&ip->i_inode, attr);
1293 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001294 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001295 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001296 brelse(dibh);
1297 }
1298
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001299 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001300
1301 return error;
1302}
1303
1304static int ea_dealloc_indirect(struct gfs2_inode *ip)
1305{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001306 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001307 struct gfs2_rgrp_list rlist;
1308 struct buffer_head *indbh, *dibh;
Al Virob44b84d2006-10-14 10:46:30 -04001309 __be64 *eablk, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001310 unsigned int rg_blocks = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -04001311 u64 bstart = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001312 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
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001319 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001320 if (error)
1321 return error;
1322
1323 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1324 error = -EIO;
1325 goto out;
1326 }
1327
Al Virob44b84d2006-10-14 10:46:30 -04001328 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001329 end = eablk + sdp->sd_inptrs;
1330
1331 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001332 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001333
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
Bob Petersonfe6c9912008-01-28 11:13:02 -06001353 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001354
1355 for (x = 0; x < rlist.rl_rgrps; x++) {
1356 struct gfs2_rgrpd *rgd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001357 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001358 rg_blocks += rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001359 }
1360
1361 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1362 if (error)
1363 goto out_rlist_free;
1364
Steven Whitehousecca195c2006-09-05 13:15:18 -04001365 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1366 RES_STATFS + RES_QUOTA, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001367 if (error)
1368 goto out_gunlock;
1369
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001370 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001371
Al Virob44b84d2006-10-14 10:46:30 -04001372 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001373 bstart = 0;
1374 blen = 0;
1375
1376 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001377 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001378
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;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001393 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001394 }
1395 if (bstart)
1396 gfs2_free_meta(ip, bstart, blen);
1397
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001398 ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001399
1400 error = gfs2_meta_inode_buffer(ip, &dibh);
1401 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001402 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001403 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001404 brelse(dibh);
1405 }
1406
1407 gfs2_trans_end(sdp);
1408
Steven Whitehousea91ea692006-09-04 12:04:26 -04001409out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001410 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001411out_rlist_free:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001412 gfs2_rlist_free(&rlist);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001413out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001414 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001415 return error;
1416}
1417
1418static int ea_dealloc_block(struct gfs2_inode *ip)
1419{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001420 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse6dbd8222008-01-10 15:18:55 +00001421 struct gfs2_alloc *al = ip->i_alloc;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001422 struct gfs2_rgrpd *rgd;
1423 struct buffer_head *dibh;
1424 int error;
1425
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001426 rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001427 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
Steven Whitehousecca195c2006-09-05 13:15:18 -04001437 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1438 RES_QUOTA, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001439 if (error)
1440 goto out_gunlock;
1441
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001442 gfs2_free_meta(ip, ip->i_eattr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001443
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001444 ip->i_eattr = 0;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001445 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001446
1447 error = gfs2_meta_inode_buffer(ip, &dibh);
1448 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001449 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001450 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001451 brelse(dibh);
1452 }
1453
1454 gfs2_trans_end(sdp);
1455
Steven Whitehousea91ea692006-09-04 12:04:26 -04001456out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001457 gfs2_glock_dq_uninit(&al->al_rgd_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001458 return error;
1459}
1460
1461/**
1462 * gfs2_ea_dealloc - deallocate the extended attribute fork
1463 * @ip: the inode
1464 *
1465 * Returns: errno
1466 */
1467
1468int gfs2_ea_dealloc(struct gfs2_inode *ip)
1469{
1470 struct gfs2_alloc *al;
1471 int error;
1472
1473 al = gfs2_alloc_get(ip);
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +03001474 if (!al)
1475 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001476
1477 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1478 if (error)
1479 goto out_alloc;
1480
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001481 error = gfs2_rindex_hold(GFS2_SB(&ip->i_inode), &al->al_ri_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001482 if (error)
1483 goto out_quota;
1484
1485 error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1486 if (error)
1487 goto out_rindex;
1488
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001489 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001490 error = ea_dealloc_indirect(ip);
1491 if (error)
1492 goto out_rindex;
1493 }
1494
1495 error = ea_dealloc_block(ip);
1496
Steven Whitehousea91ea692006-09-04 12:04:26 -04001497out_rindex:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001498 gfs2_glock_dq_uninit(&al->al_ri_gh);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001499out_quota:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001500 gfs2_quota_unhold(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001501out_alloc:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001502 gfs2_alloc_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001503 return error;
1504}
1505