blob: 2e5ba425cae743f006b938a39b8e70469c9f471a [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"
Steven Whitehouse307cf6e2009-08-26 18:51:04 +010021#include "xattr.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000022#include "glock.h"
23#include "inode.h"
24#include "meta_io.h"
25#include "quota.h"
26#include "rgrp.h"
27#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050028#include "util.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000029
30/**
31 * ea_calc_size - returns the acutal number of bytes the request will take up
32 * (not counting any unstuffed data blocks)
33 * @sdp:
34 * @er:
35 * @size:
36 *
37 * Returns: 1 if the EA should be stuffed
38 */
39
Steven Whitehouse40b78a32009-08-26 18:41:32 +010040static int ea_calc_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize,
David Teiglandb3b94fa2006-01-16 16:50:04 +000041 unsigned int *size)
42{
Steven Whitehouse40b78a32009-08-26 18:41:32 +010043 unsigned int jbsize = sdp->sd_jbsize;
44
45 /* Stuffed */
46 *size = ALIGN(sizeof(struct gfs2_ea_header) + nsize + dsize, 8);
47
48 if (*size <= jbsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +000049 return 1;
50
Steven Whitehouse40b78a32009-08-26 18:41:32 +010051 /* Unstuffed */
52 *size = ALIGN(sizeof(struct gfs2_ea_header) + nsize +
53 (sizeof(__be64) * DIV_ROUND_UP(dsize, jbsize)), 8);
David Teiglandb3b94fa2006-01-16 16:50:04 +000054
55 return 0;
56}
57
Steven Whitehouse40b78a32009-08-26 18:41:32 +010058static int ea_check_size(struct gfs2_sbd *sdp, unsigned int nsize, size_t dsize)
David Teiglandb3b94fa2006-01-16 16:50:04 +000059{
60 unsigned int size;
61
Steven Whitehouse40b78a32009-08-26 18:41:32 +010062 if (dsize > GFS2_EA_MAX_DATA_LEN)
David Teiglandb3b94fa2006-01-16 16:50:04 +000063 return -ERANGE;
64
Steven Whitehouse40b78a32009-08-26 18:41:32 +010065 ea_calc_size(sdp, nsize, dsize, &size);
David Teiglandb3b94fa2006-01-16 16:50:04 +000066
67 /* This can only happen with 512 byte blocks */
68 if (size > sdp->sd_jbsize)
69 return -ERANGE;
70
71 return 0;
72}
73
Steven Whitehousecca195c2006-09-05 13:15:18 -040074typedef int (*ea_call_t) (struct gfs2_inode *ip, struct buffer_head *bh,
David Teiglandb3b94fa2006-01-16 16:50:04 +000075 struct gfs2_ea_header *ea,
Steven Whitehousecca195c2006-09-05 13:15:18 -040076 struct gfs2_ea_header *prev, void *private);
David Teiglandb3b94fa2006-01-16 16:50:04 +000077
78static int ea_foreach_i(struct gfs2_inode *ip, struct buffer_head *bh,
79 ea_call_t ea_call, void *data)
80{
81 struct gfs2_ea_header *ea, *prev = NULL;
82 int error = 0;
83
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040084 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_EA))
David Teiglandb3b94fa2006-01-16 16:50:04 +000085 return -EIO;
86
87 for (ea = GFS2_EA_BH2FIRST(bh);; prev = ea, ea = GFS2_EA2NEXT(ea)) {
88 if (!GFS2_EA_REC_LEN(ea))
89 goto fail;
Steven Whitehousecca195c2006-09-05 13:15:18 -040090 if (!(bh->b_data <= (char *)ea && (char *)GFS2_EA2NEXT(ea) <=
91 bh->b_data + bh->b_size))
David Teiglandb3b94fa2006-01-16 16:50:04 +000092 goto fail;
93 if (!GFS2_EATYPE_VALID(ea->ea_type))
94 goto fail;
95
96 error = ea_call(ip, bh, ea, prev, data);
97 if (error)
98 return error;
99
100 if (GFS2_EA_IS_LAST(ea)) {
101 if ((char *)GFS2_EA2NEXT(ea) !=
102 bh->b_data + bh->b_size)
103 goto fail;
104 break;
105 }
106 }
107
108 return error;
109
Steven Whitehousea91ea692006-09-04 12:04:26 -0400110fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000111 gfs2_consist_inode(ip);
112 return -EIO;
113}
114
115static int ea_foreach(struct gfs2_inode *ip, ea_call_t ea_call, void *data)
116{
117 struct buffer_head *bh, *eabh;
Al Virob44b84d2006-10-14 10:46:30 -0400118 __be64 *eablk, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000119 int error;
120
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000121 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000122 if (error)
123 return error;
124
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000125 if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000126 error = ea_foreach_i(ip, bh, ea_call, data);
127 goto out;
128 }
129
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400130 if (gfs2_metatype_check(GFS2_SB(&ip->i_inode), bh, GFS2_METATYPE_IN)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000131 error = -EIO;
132 goto out;
133 }
134
Al Virob44b84d2006-10-14 10:46:30 -0400135 eablk = (__be64 *)(bh->b_data + sizeof(struct gfs2_meta_header));
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400136 end = eablk + GFS2_SB(&ip->i_inode)->sd_inptrs;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000137
138 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -0400139 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000140
141 if (!*eablk)
142 break;
143 bn = be64_to_cpu(*eablk);
144
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400145 error = gfs2_meta_read(ip->i_gl, bn, DIO_WAIT, &eabh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000146 if (error)
147 break;
148 error = ea_foreach_i(ip, eabh, ea_call, data);
149 brelse(eabh);
150 if (error)
151 break;
152 }
Steven Whitehousea91ea692006-09-04 12:04:26 -0400153out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000154 brelse(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000155 return error;
156}
157
158struct ea_find {
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100159 int type;
160 const char *name;
161 size_t namel;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000162 struct gfs2_ea_location *ef_el;
163};
164
165static int ea_find_i(struct gfs2_inode *ip, struct buffer_head *bh,
166 struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
167 void *private)
168{
169 struct ea_find *ef = private;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000170
171 if (ea->ea_type == GFS2_EATYPE_UNUSED)
172 return 0;
173
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100174 if (ea->ea_type == ef->type) {
175 if (ea->ea_name_len == ef->namel &&
176 !memcmp(GFS2_EA2NAME(ea), ef->name, ea->ea_name_len)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000177 struct gfs2_ea_location *el = ef->ef_el;
178 get_bh(bh);
179 el->el_bh = bh;
180 el->el_ea = ea;
181 el->el_prev = prev;
182 return 1;
183 }
184 }
185
David Teiglandb3b94fa2006-01-16 16:50:04 +0000186 return 0;
187}
188
Steven Whitehouse479c4272009-10-02 12:00:00 +0100189static int gfs2_ea_find(struct gfs2_inode *ip, int type, const char *name,
190 struct gfs2_ea_location *el)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000191{
192 struct ea_find ef;
193 int error;
194
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100195 ef.type = type;
196 ef.name = name;
197 ef.namel = strlen(name);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000198 ef.ef_el = el;
199
200 memset(el, 0, sizeof(struct gfs2_ea_location));
201
202 error = ea_foreach(ip, ea_find_i, &ef);
203 if (error > 0)
204 return 0;
205
206 return error;
207}
208
209/**
210 * ea_dealloc_unstuffed -
211 * @ip:
212 * @bh:
213 * @ea:
214 * @prev:
215 * @private:
216 *
217 * Take advantage of the fact that all unstuffed blocks are
218 * allocated from the same RG. But watch, this may not always
219 * be true.
220 *
221 * Returns: errno
222 */
223
224static int ea_dealloc_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
225 struct gfs2_ea_header *ea,
226 struct gfs2_ea_header *prev, void *private)
227{
228 int *leave = private;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400229 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000230 struct gfs2_rgrpd *rgd;
231 struct gfs2_holder rg_gh;
232 struct buffer_head *dibh;
Al Virob44b84d2006-10-14 10:46:30 -0400233 __be64 *dataptrs;
234 u64 bn = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -0400235 u64 bstart = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000236 unsigned int blen = 0;
237 unsigned int blks = 0;
238 unsigned int x;
239 int error;
240
241 if (GFS2_EA_IS_STUFFED(ea))
242 return 0;
243
244 dataptrs = GFS2_EA2DATAPTRS(ea);
Steven Whitehousecca195c2006-09-05 13:15:18 -0400245 for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000246 if (*dataptrs) {
247 blks++;
248 bn = be64_to_cpu(*dataptrs);
249 }
Steven Whitehousecca195c2006-09-05 13:15:18 -0400250 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000251 if (!blks)
252 return 0;
253
Steven Whitehouse66fc0612012-02-08 12:58:32 +0000254 rgd = gfs2_blk2rgrpd(sdp, bn, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000255 if (!rgd) {
256 gfs2_consist_inode(ip);
257 return -EIO;
258 }
259
260 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &rg_gh);
261 if (error)
262 return error;
263
Steven Whitehousebb8d8a62007-06-01 14:11:58 +0100264 error = gfs2_trans_begin(sdp, rgd->rd_length + RES_DINODE +
Steven Whitehousecca195c2006-09-05 13:15:18 -0400265 RES_EATTR + RES_STATFS + RES_QUOTA, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000266 if (error)
267 goto out_gunlock;
268
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000269 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000270
271 dataptrs = GFS2_EA2DATAPTRS(ea);
272 for (x = 0; x < ea->ea_num_ptrs; x++, dataptrs++) {
273 if (!*dataptrs)
274 break;
275 bn = be64_to_cpu(*dataptrs);
276
277 if (bstart + blen == bn)
278 blen++;
279 else {
280 if (bstart)
281 gfs2_free_meta(ip, bstart, blen);
282 bstart = bn;
283 blen = 1;
284 }
285
286 *dataptrs = 0;
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000287 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000288 }
289 if (bstart)
290 gfs2_free_meta(ip, bstart, blen);
291
292 if (prev && !leave) {
Steven Whitehousecd915492006-09-04 12:49:07 -0400293 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000294
295 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
296 prev->ea_rec_len = cpu_to_be32(len);
297
298 if (GFS2_EA_IS_LAST(ea))
299 prev->ea_flags |= GFS2_EAFLAG_LAST;
300 } else {
301 ea->ea_type = GFS2_EATYPE_UNUSED;
302 ea->ea_num_ptrs = 0;
303 }
304
305 error = gfs2_meta_inode_buffer(ip, &dibh);
306 if (!error) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100307 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000308 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500309 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000310 brelse(dibh);
311 }
312
313 gfs2_trans_end(sdp);
314
Steven Whitehousea91ea692006-09-04 12:04:26 -0400315out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000316 gfs2_glock_dq_uninit(&rg_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000317 return error;
318}
319
320static int ea_remove_unstuffed(struct gfs2_inode *ip, struct buffer_head *bh,
321 struct gfs2_ea_header *ea,
322 struct gfs2_ea_header *prev, int leave)
323{
Bob Peterson564e12b2011-11-21 13:36:17 -0500324 struct gfs2_qadata *qa;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000325 int error;
326
Bob Peterson564e12b2011-11-21 13:36:17 -0500327 qa = gfs2_qadata_get(ip);
328 if (!qa)
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +0300329 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000330
331 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
332 if (error)
333 goto out_alloc;
334
Steven Whitehousecca195c2006-09-05 13:15:18 -0400335 error = ea_dealloc_unstuffed(ip, bh, ea, prev, (leave) ? &error : NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000336
David Teiglandb3b94fa2006-01-16 16:50:04 +0000337 gfs2_quota_unhold(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400338out_alloc:
Bob Peterson564e12b2011-11-21 13:36:17 -0500339 gfs2_qadata_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000340 return error;
341}
342
David Teiglandb3b94fa2006-01-16 16:50:04 +0000343struct ea_list {
344 struct gfs2_ea_request *ei_er;
345 unsigned int ei_size;
346};
347
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100348static inline unsigned int gfs2_ea_strlen(struct gfs2_ea_header *ea)
349{
350 switch (ea->ea_type) {
351 case GFS2_EATYPE_USR:
352 return 5 + ea->ea_name_len + 1;
353 case GFS2_EATYPE_SYS:
354 return 7 + ea->ea_name_len + 1;
355 case GFS2_EATYPE_SECURITY:
356 return 9 + ea->ea_name_len + 1;
357 default:
358 return 0;
359 }
360}
361
David Teiglandb3b94fa2006-01-16 16:50:04 +0000362static int ea_list_i(struct gfs2_inode *ip, struct buffer_head *bh,
363 struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
364 void *private)
365{
366 struct ea_list *ei = private;
367 struct gfs2_ea_request *er = ei->ei_er;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400368 unsigned int ea_size = gfs2_ea_strlen(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000369
370 if (ea->ea_type == GFS2_EATYPE_UNUSED)
371 return 0;
372
373 if (er->er_data_len) {
Steven Whitehouse01eb7c02006-06-06 17:31:30 -0400374 char *prefix = NULL;
375 unsigned int l = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000376 char c = 0;
377
378 if (ei->ei_size + ea_size > er->er_data_len)
379 return -ERANGE;
380
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400381 switch (ea->ea_type) {
382 case GFS2_EATYPE_USR:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000383 prefix = "user.";
384 l = 5;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400385 break;
386 case GFS2_EATYPE_SYS:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000387 prefix = "system.";
388 l = 7;
Ryan O'Hara639b6d72006-05-22 10:08:35 -0400389 break;
390 case GFS2_EATYPE_SECURITY:
391 prefix = "security.";
392 l = 9;
393 break;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000394 }
395
Steven Whitehouse01eb7c02006-06-06 17:31:30 -0400396 BUG_ON(l == 0);
397
Steven Whitehouse90cdd202006-05-22 10:36:25 -0400398 memcpy(er->er_data + ei->ei_size, prefix, l);
399 memcpy(er->er_data + ei->ei_size + l, GFS2_EA2NAME(ea),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000400 ea->ea_name_len);
Steven Whitehouse90cdd202006-05-22 10:36:25 -0400401 memcpy(er->er_data + ei->ei_size + ea_size - 1, &c, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000402 }
403
404 ei->ei_size += ea_size;
405
406 return 0;
407}
408
409/**
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100410 * gfs2_listxattr - List gfs2 extended attributes
411 * @dentry: The dentry whose inode we are interested in
412 * @buffer: The buffer to write the results
413 * @size: The size of the buffer
David Teiglandb3b94fa2006-01-16 16:50:04 +0000414 *
415 * Returns: actual size of data on success, -errno on error
416 */
417
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100418ssize_t gfs2_listxattr(struct dentry *dentry, char *buffer, size_t size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000419{
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100420 struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
421 struct gfs2_ea_request er;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422 struct gfs2_holder i_gh;
423 int error;
424
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100425 memset(&er, 0, sizeof(struct gfs2_ea_request));
426 if (size) {
427 er.er_data = buffer;
428 er.er_data_len = size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000429 }
430
Steven Whitehousecca195c2006-09-05 13:15:18 -0400431 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000432 if (error)
433 return error;
434
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000435 if (ip->i_eattr) {
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100436 struct ea_list ei = { .ei_er = &er, .ei_size = 0 };
David Teiglandb3b94fa2006-01-16 16:50:04 +0000437
438 error = ea_foreach(ip, ea_list_i, &ei);
439 if (!error)
440 error = ei.ei_size;
441 }
442
443 gfs2_glock_dq_uninit(&i_gh);
444
445 return error;
446}
447
448/**
449 * ea_get_unstuffed - actually copies the unstuffed data into the
450 * request buffer
Steven Whitehousecca195c2006-09-05 13:15:18 -0400451 * @ip: The GFS2 inode
452 * @ea: The extended attribute header structure
453 * @data: The data to be copied
David Teiglandb3b94fa2006-01-16 16:50:04 +0000454 *
455 * Returns: errno
456 */
457
458static int ea_get_unstuffed(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
459 char *data)
460{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400461 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000462 struct buffer_head **bh;
463 unsigned int amount = GFS2_EA_DATA_LEN(ea);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500464 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
Al Virob44b84d2006-10-14 10:46:30 -0400465 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466 unsigned int x;
467 int error = 0;
468
Josef Bacik16c5f062008-04-09 09:33:41 -0400469 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000470 if (!bh)
471 return -ENOMEM;
472
473 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400474 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
475 bh + x);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000476 if (error) {
477 while (x--)
478 brelse(bh[x]);
479 goto out;
480 }
481 dataptrs++;
482 }
483
484 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400485 error = gfs2_meta_wait(sdp, bh[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000486 if (error) {
487 for (; x < nptrs; x++)
488 brelse(bh[x]);
489 goto out;
490 }
491 if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {
492 for (; x < nptrs; x++)
493 brelse(bh[x]);
494 error = -EIO;
495 goto out;
496 }
497
Steven Whitehousecca195c2006-09-05 13:15:18 -0400498 memcpy(data, bh[x]->b_data + sizeof(struct gfs2_meta_header),
David Teiglandb3b94fa2006-01-16 16:50:04 +0000499 (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize);
500
501 amount -= sdp->sd_jbsize;
502 data += sdp->sd_jbsize;
503
504 brelse(bh[x]);
505 }
506
Steven Whitehousea91ea692006-09-04 12:04:26 -0400507out:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000508 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000509 return error;
510}
511
Steven Whitehouse479c4272009-10-02 12:00:00 +0100512static int gfs2_ea_get_copy(struct gfs2_inode *ip, struct gfs2_ea_location *el,
513 char *data, size_t size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000514{
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100515 int ret;
516 size_t len = GFS2_EA_DATA_LEN(el->el_ea);
517 if (len > size)
518 return -ERANGE;
519
David Teiglandb3b94fa2006-01-16 16:50:04 +0000520 if (GFS2_EA_IS_STUFFED(el->el_ea)) {
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100521 memcpy(data, GFS2_EA2DATA(el->el_ea), len);
522 return len;
523 }
524 ret = ea_get_unstuffed(ip, el->el_ea, data);
525 if (ret < 0)
526 return ret;
527 return len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000528}
529
Steven Whitehouse479c4272009-10-02 12:00:00 +0100530int gfs2_xattr_acl_get(struct gfs2_inode *ip, const char *name, char **ppdata)
531{
532 struct gfs2_ea_location el;
533 int error;
534 int len;
535 char *data;
536
537 error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, name, &el);
538 if (error)
539 return error;
540 if (!el.el_ea)
541 goto out;
542 if (!GFS2_EA_DATA_LEN(el.el_ea))
543 goto out;
544
545 len = GFS2_EA_DATA_LEN(el.el_ea);
546 data = kmalloc(len, GFP_NOFS);
547 error = -ENOMEM;
548 if (data == NULL)
549 goto out;
550
551 error = gfs2_ea_get_copy(ip, &el, data, len);
Steven Whitehouse114b80c2011-11-09 12:54:43 +0000552 if (error < 0)
553 kfree(data);
554 else
555 *ppdata = data;
Steven Whitehouse479c4272009-10-02 12:00:00 +0100556out:
557 brelse(el.el_bh);
558 return error;
559}
560
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561/**
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100562 * gfs2_xattr_get - Get a GFS2 extended attribute
563 * @inode: The inode
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100564 * @name: The name of the extended attribute
565 * @buffer: The buffer to write the result into
566 * @size: The size of the buffer
Christoph Hellwig431547b2009-11-13 09:52:56 +0000567 * @type: The type of extended attribute
David Teiglandb3b94fa2006-01-16 16:50:04 +0000568 *
569 * Returns: actual size of data on success, -errno on error
570 */
Christoph Hellwig431547b2009-11-13 09:52:56 +0000571static int gfs2_xattr_get(struct dentry *dentry, const char *name,
572 void *buffer, size_t size, int type)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000573{
Christoph Hellwig431547b2009-11-13 09:52:56 +0000574 struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000575 struct gfs2_ea_location el;
576 int error;
577
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000578 if (!ip->i_eattr)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000579 return -ENODATA;
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100580 if (strlen(name) > GFS2_EA_MAX_NAME_LEN)
581 return -EINVAL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000582
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100583 error = gfs2_ea_find(ip, type, name, &el);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000584 if (error)
585 return error;
586 if (!el.el_ea)
587 return -ENODATA;
Steven Whitehouse86d00632009-09-14 09:50:57 +0100588 if (size)
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100589 error = gfs2_ea_get_copy(ip, &el, buffer, size);
590 else
David Teiglandb3b94fa2006-01-16 16:50:04 +0000591 error = GFS2_EA_DATA_LEN(el.el_ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000592 brelse(el.el_bh);
593
594 return error;
595}
596
597/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000598 * ea_alloc_blk - allocates a new block for extended attributes.
599 * @ip: A pointer to the inode that's getting extended attributes
Steven Whitehousecca195c2006-09-05 13:15:18 -0400600 * @bhp: Pointer to pointer to a struct buffer_head
David Teiglandb3b94fa2006-01-16 16:50:04 +0000601 *
602 * Returns: errno
603 */
604
605static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp)
606{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400607 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000608 struct gfs2_ea_header *ea;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000609 unsigned int n = 1;
Steven Whitehousecd915492006-09-04 12:49:07 -0400610 u64 block;
Steven Whitehouse09010972009-05-20 10:48:47 +0100611 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000612
Bob Peterson6e87ed02011-11-18 10:58:32 -0500613 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100614 if (error)
615 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000616 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000617 *bhp = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000618 gfs2_trans_add_bh(ip->i_gl, *bhp, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000619 gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
620 gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header));
621
622 ea = GFS2_EA_BH2FIRST(*bhp);
623 ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
624 ea->ea_type = GFS2_EATYPE_UNUSED;
625 ea->ea_flags = GFS2_EAFLAG_LAST;
626 ea->ea_num_ptrs = 0;
627
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000628 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000629
630 return 0;
631}
632
633/**
634 * ea_write - writes the request info to an ea, creating new blocks if
635 * necessary
Steven Whitehousecca195c2006-09-05 13:15:18 -0400636 * @ip: inode that is being modified
637 * @ea: the location of the new ea in a block
David Teiglandb3b94fa2006-01-16 16:50:04 +0000638 * @er: the write request
639 *
640 * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
641 *
642 * returns : errno
643 */
644
645static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
646 struct gfs2_ea_request *er)
647{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400648 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
Steven Whitehouse09010972009-05-20 10:48:47 +0100649 int error;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000650
651 ea->ea_data_len = cpu_to_be32(er->er_data_len);
652 ea->ea_name_len = er->er_name_len;
653 ea->ea_type = er->er_type;
654 ea->__pad = 0;
655
656 memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);
657
658 if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {
659 ea->ea_num_ptrs = 0;
660 memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);
661 } else {
Al Virob44b84d2006-10-14 10:46:30 -0400662 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000663 const char *data = er->er_data;
664 unsigned int data_len = er->er_data_len;
665 unsigned int copy;
666 unsigned int x;
667
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500668 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000669 for (x = 0; x < ea->ea_num_ptrs; x++) {
670 struct buffer_head *bh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400671 u64 block;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000672 int mh_size = sizeof(struct gfs2_meta_header);
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000673 unsigned int n = 1;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000674
Bob Peterson6e87ed02011-11-18 10:58:32 -0500675 error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100676 if (error)
677 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000678 gfs2_trans_add_unrevoke(sdp, block, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000679 bh = gfs2_meta_new(ip->i_gl, block);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000680 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000681 gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
682
Steven Whitehouse77658aa2008-02-12 14:17:27 +0000683 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000684
Steven Whitehousecca195c2006-09-05 13:15:18 -0400685 copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
686 data_len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000687 memcpy(bh->b_data + mh_size, data, copy);
688 if (copy < sdp->sd_jbsize)
689 memset(bh->b_data + mh_size + copy, 0,
690 sdp->sd_jbsize - copy);
691
Steven Whitehousecca195c2006-09-05 13:15:18 -0400692 *dataptr++ = cpu_to_be64(bh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000693 data += copy;
694 data_len -= copy;
695
696 brelse(bh);
697 }
698
699 gfs2_assert_withdraw(sdp, !data_len);
700 }
701
702 return 0;
703}
704
705typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400706 struct gfs2_ea_request *er, void *private);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000707
708static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
709 unsigned int blks,
Steven Whitehousecca195c2006-09-05 13:15:18 -0400710 ea_skeleton_call_t skeleton_call, void *private)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000711{
Bob Peterson564e12b2011-11-21 13:36:17 -0500712 struct gfs2_qadata *qa;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000713 struct buffer_head *dibh;
714 int error;
715
Bob Peterson564e12b2011-11-21 13:36:17 -0500716 qa = gfs2_qadata_get(ip);
717 if (!qa)
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +0300718 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000719
Steven Whitehoused82661d2008-03-10 15:34:50 +0000720 error = gfs2_quota_lock_check(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000721 if (error)
722 goto out;
723
Bob Peterson564e12b2011-11-21 13:36:17 -0500724 error = gfs2_inplace_reserve(ip, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000725 if (error)
726 goto out_gunlock_q;
727
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400728 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
Steven Whitehouse54335b12011-09-01 13:31:59 +0100729 blks + gfs2_rg_blocks(ip) +
David Teiglandb3b94fa2006-01-16 16:50:04 +0000730 RES_DINODE + RES_STATFS + RES_QUOTA, 0);
731 if (error)
732 goto out_ipres;
733
734 error = skeleton_call(ip, er, private);
735 if (error)
736 goto out_end_trans;
737
738 error = gfs2_meta_inode_buffer(ip, &dibh);
739 if (!error) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100740 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000741 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500742 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000743 brelse(dibh);
744 }
745
Steven Whitehousea91ea692006-09-04 12:04:26 -0400746out_end_trans:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400747 gfs2_trans_end(GFS2_SB(&ip->i_inode));
Steven Whitehousea91ea692006-09-04 12:04:26 -0400748out_ipres:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000749 gfs2_inplace_release(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400750out_gunlock_q:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000751 gfs2_quota_unlock(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400752out:
Bob Peterson564e12b2011-11-21 13:36:17 -0500753 gfs2_qadata_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000754 return error;
755}
756
757static int ea_init_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
758 void *private)
759{
760 struct buffer_head *bh;
761 int error;
762
763 error = ea_alloc_blk(ip, &bh);
764 if (error)
765 return error;
766
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000767 ip->i_eattr = bh->b_blocknr;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000768 error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
769
770 brelse(bh);
771
772 return error;
773}
774
775/**
776 * ea_init - initializes a new eattr block
777 * @ip:
778 * @er:
779 *
780 * Returns: errno
781 */
782
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100783static int ea_init(struct gfs2_inode *ip, int type, const char *name,
784 const void *data, size_t size)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000785{
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100786 struct gfs2_ea_request er;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400787 unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000788 unsigned int blks = 1;
789
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100790 er.er_type = type;
791 er.er_name = name;
792 er.er_name_len = strlen(name);
793 er.er_data = (void *)data;
794 er.er_data_len = size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000795
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100796 if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize)
797 blks += DIV_ROUND_UP(er.er_data_len, jbsize);
798
799 return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000800}
801
802static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
803{
Steven Whitehousecd915492006-09-04 12:49:07 -0400804 u32 ea_size = GFS2_EA_SIZE(ea);
Steven Whitehouse568f4c92006-02-27 12:00:42 -0500805 struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
806 ea_size);
Steven Whitehousecd915492006-09-04 12:49:07 -0400807 u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000808 int last = ea->ea_flags & GFS2_EAFLAG_LAST;
809
810 ea->ea_rec_len = cpu_to_be32(ea_size);
811 ea->ea_flags ^= last;
812
813 new->ea_rec_len = cpu_to_be32(new_size);
814 new->ea_flags = last;
815
816 return new;
817}
818
819static void ea_set_remove_stuffed(struct gfs2_inode *ip,
820 struct gfs2_ea_location *el)
821{
822 struct gfs2_ea_header *ea = el->el_ea;
823 struct gfs2_ea_header *prev = el->el_prev;
Steven Whitehousecd915492006-09-04 12:49:07 -0400824 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000825
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000826 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000827
828 if (!prev || !GFS2_EA_IS_STUFFED(ea)) {
829 ea->ea_type = GFS2_EATYPE_UNUSED;
830 return;
831 } else if (GFS2_EA2NEXT(prev) != ea) {
832 prev = GFS2_EA2NEXT(prev);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400833 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000834 }
835
836 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
837 prev->ea_rec_len = cpu_to_be32(len);
838
839 if (GFS2_EA_IS_LAST(ea))
840 prev->ea_flags |= GFS2_EAFLAG_LAST;
841}
842
843struct ea_set {
844 int ea_split;
845
846 struct gfs2_ea_request *es_er;
847 struct gfs2_ea_location *es_el;
848
849 struct buffer_head *es_bh;
850 struct gfs2_ea_header *es_ea;
851};
852
853static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh,
854 struct gfs2_ea_header *ea, struct ea_set *es)
855{
856 struct gfs2_ea_request *er = es->es_er;
857 struct buffer_head *dibh;
858 int error;
859
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400860 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000861 if (error)
862 return error;
863
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000864 gfs2_trans_add_bh(ip->i_gl, bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000865
866 if (es->ea_split)
867 ea = ea_split_ea(ea);
868
869 ea_write(ip, ea, er);
870
871 if (es->es_el)
872 ea_set_remove_stuffed(ip, es->es_el);
873
874 error = gfs2_meta_inode_buffer(ip, &dibh);
875 if (error)
876 goto out;
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +0100877 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000878 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500879 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000880 brelse(dibh);
Steven Whitehousea91ea692006-09-04 12:04:26 -0400881out:
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400882 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +0000883 return error;
884}
885
886static int ea_set_simple_alloc(struct gfs2_inode *ip,
887 struct gfs2_ea_request *er, void *private)
888{
889 struct ea_set *es = private;
890 struct gfs2_ea_header *ea = es->es_ea;
891 int error;
892
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000893 gfs2_trans_add_bh(ip->i_gl, es->es_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000894
895 if (es->ea_split)
896 ea = ea_split_ea(ea);
897
898 error = ea_write(ip, ea, er);
899 if (error)
900 return error;
901
902 if (es->es_el)
903 ea_set_remove_stuffed(ip, es->es_el);
904
905 return 0;
906}
907
908static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh,
909 struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
910 void *private)
911{
912 struct ea_set *es = private;
913 unsigned int size;
914 int stuffed;
915 int error;
916
Steven Whitehouse40b78a32009-08-26 18:41:32 +0100917 stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,
918 es->es_er->er_data_len, &size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000919
920 if (ea->ea_type == GFS2_EATYPE_UNUSED) {
921 if (GFS2_EA_REC_LEN(ea) < size)
922 return 0;
923 if (!GFS2_EA_IS_STUFFED(ea)) {
924 error = ea_remove_unstuffed(ip, bh, ea, prev, 1);
925 if (error)
926 return error;
927 }
928 es->ea_split = 0;
929 } else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)
930 es->ea_split = 1;
931 else
932 return 0;
933
934 if (stuffed) {
935 error = ea_set_simple_noalloc(ip, bh, ea, es);
936 if (error)
937 return error;
938 } else {
939 unsigned int blks;
940
941 es->es_bh = bh;
942 es->es_ea = ea;
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500943 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400944 GFS2_SB(&ip->i_inode)->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000945
946 error = ea_alloc_skeleton(ip, es->es_er, blks,
947 ea_set_simple_alloc, es);
948 if (error)
949 return error;
950 }
951
952 return 1;
953}
954
955static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
956 void *private)
957{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400958 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000959 struct buffer_head *indbh, *newbh;
Al Virob44b84d2006-10-14 10:46:30 -0400960 __be64 *eablk;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000961 int error;
962 int mh_size = sizeof(struct gfs2_meta_header);
963
Steven Whitehouse383f01f2008-11-04 10:05:22 +0000964 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
Al Virob44b84d2006-10-14 10:46:30 -0400965 __be64 *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000966
Steven Whitehouse3767ac22008-11-03 14:28:42 +0000967 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT,
Steven Whitehouse7276b3b2006-09-21 17:05:23 -0400968 &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000969 if (error)
970 return error;
971
972 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
973 error = -EIO;
974 goto out;
975 }
976
Al Virob44b84d2006-10-14 10:46:30 -0400977 eablk = (__be64 *)(indbh->b_data + mh_size);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000978 end = eablk + sdp->sd_inptrs;
979
980 for (; eablk < end; eablk++)
981 if (!*eablk)
982 break;
983
984 if (eablk == end) {
985 error = -ENOSPC;
986 goto out;
987 }
988
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000989 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000990 } else {
Steven Whitehousecd915492006-09-04 12:49:07 -0400991 u64 blk;
Steven Whitehouseb45e41d2008-02-06 10:11:15 +0000992 unsigned int n = 1;
Bob Peterson6e87ed02011-11-18 10:58:32 -0500993 error = gfs2_alloc_blocks(ip, &blk, &n, 0, NULL);
Steven Whitehouse09010972009-05-20 10:48:47 +0100994 if (error)
995 return error;
Steven Whitehouse5731be52008-02-01 13:16:55 +0000996 gfs2_trans_add_unrevoke(sdp, blk, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000997 indbh = gfs2_meta_new(ip->i_gl, blk);
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +0000998 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000999 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
1000 gfs2_buffer_clear_tail(indbh, mh_size);
1001
Al Virob44b84d2006-10-14 10:46:30 -04001002 eablk = (__be64 *)(indbh->b_data + mh_size);
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001003 *eablk = cpu_to_be64(ip->i_eattr);
1004 ip->i_eattr = blk;
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001005 ip->i_diskflags |= GFS2_DIF_EA_INDIRECT;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001006 gfs2_add_inode_blocks(&ip->i_inode, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001007
1008 eablk++;
1009 }
1010
1011 error = ea_alloc_blk(ip, &newbh);
1012 if (error)
1013 goto out;
1014
Steven Whitehousecd915492006-09-04 12:49:07 -04001015 *eablk = cpu_to_be64((u64)newbh->b_blocknr);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001016 error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
1017 brelse(newbh);
1018 if (error)
1019 goto out;
1020
1021 if (private)
Steven Whitehousecca195c2006-09-05 13:15:18 -04001022 ea_set_remove_stuffed(ip, private);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001023
Steven Whitehousea91ea692006-09-04 12:04:26 -04001024out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001025 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001026 return error;
1027}
1028
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001029static int ea_set_i(struct gfs2_inode *ip, int type, const char *name,
1030 const void *value, size_t size, struct gfs2_ea_location *el)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001031{
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001032 struct gfs2_ea_request er;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001033 struct ea_set es;
1034 unsigned int blks = 2;
1035 int error;
1036
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001037 er.er_type = type;
1038 er.er_name = name;
1039 er.er_data = (void *)value;
1040 er.er_name_len = strlen(name);
1041 er.er_data_len = size;
1042
David Teiglandb3b94fa2006-01-16 16:50:04 +00001043 memset(&es, 0, sizeof(struct ea_set));
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001044 es.es_er = &er;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001045 es.es_el = el;
1046
1047 error = ea_foreach(ip, ea_set_simple, &es);
1048 if (error > 0)
1049 return 0;
1050 if (error)
1051 return error;
1052
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001053 if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
David Teiglandb3b94fa2006-01-16 16:50:04 +00001054 blks++;
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001055 if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize)
1056 blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001057
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001058 return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001059}
1060
1061static int ea_set_remove_unstuffed(struct gfs2_inode *ip,
1062 struct gfs2_ea_location *el)
1063{
1064 if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {
1065 el->el_prev = GFS2_EA2NEXT(el->el_prev);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001066 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
David Teiglandb3b94fa2006-01-16 16:50:04 +00001067 GFS2_EA2NEXT(el->el_prev) == el->el_ea);
1068 }
1069
Steven Whitehouse86d00632009-09-14 09:50:57 +01001070 return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001071}
1072
David Teiglandb3b94fa2006-01-16 16:50:04 +00001073static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el)
1074{
1075 struct gfs2_ea_header *ea = el->el_ea;
1076 struct gfs2_ea_header *prev = el->el_prev;
1077 struct buffer_head *dibh;
1078 int error;
1079
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001080 error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001081 if (error)
1082 return error;
1083
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001084 gfs2_trans_add_bh(ip->i_gl, el->el_bh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001085
1086 if (prev) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001087 u32 len;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001088
1089 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
1090 prev->ea_rec_len = cpu_to_be32(len);
1091
1092 if (GFS2_EA_IS_LAST(ea))
1093 prev->ea_flags |= GFS2_EAFLAG_LAST;
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001094 } else {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001095 ea->ea_type = GFS2_EATYPE_UNUSED;
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001096 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001097
1098 error = gfs2_meta_inode_buffer(ip, &dibh);
1099 if (!error) {
Steven Whitehouse4bd91ba2007-06-05 09:39:18 +01001100 ip->i_inode.i_ctime = CURRENT_TIME;
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001101 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001102 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001103 brelse(dibh);
Steven Whitehouse907b9bc2006-09-25 09:26:04 -04001104 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001105
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001106 gfs2_trans_end(GFS2_SB(&ip->i_inode));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001107
1108 return error;
1109}
1110
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001111/**
1112 * gfs2_xattr_remove - Remove a GFS2 extended attribute
Christoph Hellwig431547b2009-11-13 09:52:56 +00001113 * @ip: The inode
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001114 * @type: The type of the extended attribute
1115 * @name: The name of the extended attribute
1116 *
1117 * This is not called directly by the VFS since we use the (common)
1118 * scheme of making a "set with NULL data" mean a remove request. Note
1119 * that this is different from a set with zero length data.
1120 *
1121 * Returns: 0, or errno on failure
1122 */
1123
Christoph Hellwig431547b2009-11-13 09:52:56 +00001124static int gfs2_xattr_remove(struct gfs2_inode *ip, int type, const char *name)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001125{
1126 struct gfs2_ea_location el;
1127 int error;
1128
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001129 if (!ip->i_eattr)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001130 return -ENODATA;
1131
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001132 error = gfs2_ea_find(ip, type, name, &el);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001133 if (error)
1134 return error;
1135 if (!el.el_ea)
1136 return -ENODATA;
1137
1138 if (GFS2_EA_IS_STUFFED(el.el_ea))
1139 error = ea_remove_stuffed(ip, &el);
1140 else
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001141 error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001142
1143 brelse(el.el_bh);
1144
1145 return error;
1146}
1147
1148/**
Christoph Hellwig431547b2009-11-13 09:52:56 +00001149 * __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1150 * @ip: The inode
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001151 * @name: The name of the extended attribute
1152 * @value: The value of the extended attribute (NULL for remove)
1153 * @size: The size of the @value argument
1154 * @flags: Create or Replace
Christoph Hellwig431547b2009-11-13 09:52:56 +00001155 * @type: The type of the extended attribute
David Teiglandb3b94fa2006-01-16 16:50:04 +00001156 *
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001157 * See gfs2_xattr_remove() for details of the removal of xattrs.
1158 *
1159 * Returns: 0 or errno on failure
David Teiglandb3b94fa2006-01-16 16:50:04 +00001160 */
1161
Christoph Hellwig431547b2009-11-13 09:52:56 +00001162int __gfs2_xattr_set(struct inode *inode, const char *name,
1163 const void *value, size_t size, int flags, int type)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001164{
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001165 struct gfs2_inode *ip = GFS2_I(inode);
Christoph Hellwig431547b2009-11-13 09:52:56 +00001166 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001167 struct gfs2_ea_location el;
1168 unsigned int namel = strlen(name);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001169 int error;
1170
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001171 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1172 return -EPERM;
1173 if (namel > GFS2_EA_MAX_NAME_LEN)
1174 return -ERANGE;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001175
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001176 if (value == NULL)
Christoph Hellwig431547b2009-11-13 09:52:56 +00001177 return gfs2_xattr_remove(ip, type, name);
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001178
1179 if (ea_check_size(sdp, namel, size))
1180 return -ERANGE;
1181
1182 if (!ip->i_eattr) {
1183 if (flags & XATTR_REPLACE)
1184 return -ENODATA;
1185 return ea_init(ip, type, name, value, size);
1186 }
1187
1188 error = gfs2_ea_find(ip, type, name, &el);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001189 if (error)
1190 return error;
1191
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001192 if (el.el_ea) {
1193 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
1194 brelse(el.el_bh);
1195 return -EPERM;
1196 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001197
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001198 error = -EEXIST;
1199 if (!(flags & XATTR_CREATE)) {
1200 int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);
1201 error = ea_set_i(ip, type, name, value, size, &el);
1202 if (!error && unstuffed)
1203 ea_set_remove_unstuffed(ip, &el);
1204 }
1205
1206 brelse(el.el_bh);
1207 return error;
1208 }
1209
1210 error = -ENODATA;
1211 if (!(flags & XATTR_REPLACE))
1212 error = ea_set_i(ip, type, name, value, size, NULL);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001213
1214 return error;
1215}
1216
Christoph Hellwig431547b2009-11-13 09:52:56 +00001217static int gfs2_xattr_set(struct dentry *dentry, const char *name,
1218 const void *value, size_t size, int flags, int type)
1219{
1220 return __gfs2_xattr_set(dentry->d_inode, name, value,
1221 size, flags, type);
1222}
1223
David Teiglandb3b94fa2006-01-16 16:50:04 +00001224static int ea_acl_chmod_unstuffed(struct gfs2_inode *ip,
1225 struct gfs2_ea_header *ea, char *data)
1226{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001227 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001228 struct buffer_head **bh;
1229 unsigned int amount = GFS2_EA_DATA_LEN(ea);
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001230 unsigned int nptrs = DIV_ROUND_UP(amount, sdp->sd_jbsize);
Al Virob44b84d2006-10-14 10:46:30 -04001231 __be64 *dataptrs = GFS2_EA2DATAPTRS(ea);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001232 unsigned int x;
1233 int error;
1234
Josef Bacik16c5f062008-04-09 09:33:41 -04001235 bh = kcalloc(nptrs, sizeof(struct buffer_head *), GFP_NOFS);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001236 if (!bh)
1237 return -ENOMEM;
1238
1239 error = gfs2_trans_begin(sdp, nptrs + RES_DINODE, 0);
1240 if (error)
1241 goto out;
1242
1243 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001244 error = gfs2_meta_read(ip->i_gl, be64_to_cpu(*dataptrs), 0,
1245 bh + x);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001246 if (error) {
1247 while (x--)
1248 brelse(bh[x]);
1249 goto fail;
1250 }
1251 dataptrs++;
1252 }
1253
1254 for (x = 0; x < nptrs; x++) {
Steven Whitehouse7276b3b2006-09-21 17:05:23 -04001255 error = gfs2_meta_wait(sdp, bh[x]);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001256 if (error) {
1257 for (; x < nptrs; x++)
1258 brelse(bh[x]);
1259 goto fail;
1260 }
1261 if (gfs2_metatype_check(sdp, bh[x], GFS2_METATYPE_ED)) {
1262 for (; x < nptrs; x++)
1263 brelse(bh[x]);
1264 error = -EIO;
1265 goto fail;
1266 }
1267
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001268 gfs2_trans_add_bh(ip->i_gl, bh[x], 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001269
Steven Whitehousecca195c2006-09-05 13:15:18 -04001270 memcpy(bh[x]->b_data + sizeof(struct gfs2_meta_header), data,
David Teiglandb3b94fa2006-01-16 16:50:04 +00001271 (sdp->sd_jbsize > amount) ? amount : sdp->sd_jbsize);
1272
1273 amount -= sdp->sd_jbsize;
1274 data += sdp->sd_jbsize;
1275
1276 brelse(bh[x]);
1277 }
1278
Steven Whitehousea91ea692006-09-04 12:04:26 -04001279out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001280 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001281 return error;
1282
Steven Whitehousea91ea692006-09-04 12:04:26 -04001283fail:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001284 gfs2_trans_end(sdp);
1285 kfree(bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001286 return error;
1287}
1288
Steven Whitehouse479c4272009-10-02 12:00:00 +01001289int gfs2_xattr_acl_chmod(struct gfs2_inode *ip, struct iattr *attr, char *data)
David Teiglandb3b94fa2006-01-16 16:50:04 +00001290{
Steven Whitehouseab9bbda2011-08-15 14:20:36 +01001291 struct inode *inode = &ip->i_inode;
1292 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse479c4272009-10-02 12:00:00 +01001293 struct gfs2_ea_location el;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001294 int error;
1295
Steven Whitehouse479c4272009-10-02 12:00:00 +01001296 error = gfs2_ea_find(ip, GFS2_EATYPE_SYS, GFS2_POSIX_ACL_ACCESS, &el);
1297 if (error)
1298 return error;
1299
1300 if (GFS2_EA_IS_STUFFED(el.el_ea)) {
Steven Whitehousee412bdb2009-12-21 13:55:28 +00001301 error = gfs2_trans_begin(sdp, RES_DINODE + RES_EATTR, 0);
1302 if (error == 0) {
1303 gfs2_trans_add_bh(ip->i_gl, el.el_bh, 1);
1304 memcpy(GFS2_EA2DATA(el.el_ea), data,
1305 GFS2_EA_DATA_LEN(el.el_ea));
1306 }
1307 } else {
Steven Whitehouse479c4272009-10-02 12:00:00 +01001308 error = ea_acl_chmod_unstuffed(ip, el.el_ea, data);
Steven Whitehousee412bdb2009-12-21 13:55:28 +00001309 }
David Teiglandb3b94fa2006-01-16 16:50:04 +00001310
Steven Whitehousee412bdb2009-12-21 13:55:28 +00001311 brelse(el.el_bh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001312 if (error)
1313 return error;
1314
Steven Whitehouseab9bbda2011-08-15 14:20:36 +01001315 error = gfs2_setattr_simple(inode, attr);
Steven Whitehousee412bdb2009-12-21 13:55:28 +00001316 gfs2_trans_end(sdp);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001317 return error;
1318}
1319
1320static int ea_dealloc_indirect(struct gfs2_inode *ip)
1321{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001322 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001323 struct gfs2_rgrp_list rlist;
1324 struct buffer_head *indbh, *dibh;
Al Virob44b84d2006-10-14 10:46:30 -04001325 __be64 *eablk, *end;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001326 unsigned int rg_blocks = 0;
Steven Whitehousecd915492006-09-04 12:49:07 -04001327 u64 bstart = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001328 unsigned int blen = 0;
1329 unsigned int blks = 0;
1330 unsigned int x;
1331 int error;
1332
1333 memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1334
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001335 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, &indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001336 if (error)
1337 return error;
1338
1339 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1340 error = -EIO;
1341 goto out;
1342 }
1343
Al Virob44b84d2006-10-14 10:46:30 -04001344 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001345 end = eablk + sdp->sd_inptrs;
1346
1347 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001348 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001349
1350 if (!*eablk)
1351 break;
1352 bn = be64_to_cpu(*eablk);
1353
1354 if (bstart + blen == bn)
1355 blen++;
1356 else {
1357 if (bstart)
Steven Whitehouse70b0c362011-09-02 16:08:09 +01001358 gfs2_rlist_add(ip, &rlist, bstart);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001359 bstart = bn;
1360 blen = 1;
1361 }
1362 blks++;
1363 }
1364 if (bstart)
Steven Whitehouse70b0c362011-09-02 16:08:09 +01001365 gfs2_rlist_add(ip, &rlist, bstart);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001366 else
1367 goto out;
1368
Bob Petersonfe6c9912008-01-28 11:13:02 -06001369 gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001370
1371 for (x = 0; x < rlist.rl_rgrps; x++) {
1372 struct gfs2_rgrpd *rgd;
Steven Whitehouse5c676f62006-02-27 17:23:27 -05001373 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
Steven Whitehousebb8d8a62007-06-01 14:11:58 +01001374 rg_blocks += rgd->rd_length;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001375 }
1376
1377 error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1378 if (error)
1379 goto out_rlist_free;
1380
Steven Whitehousecca195c2006-09-05 13:15:18 -04001381 error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1382 RES_STATFS + RES_QUOTA, blks);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001383 if (error)
1384 goto out_gunlock;
1385
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001386 gfs2_trans_add_bh(ip->i_gl, indbh, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001387
Al Virob44b84d2006-10-14 10:46:30 -04001388 eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
David Teiglandb3b94fa2006-01-16 16:50:04 +00001389 bstart = 0;
1390 blen = 0;
1391
1392 for (; eablk < end; eablk++) {
Steven Whitehousecd915492006-09-04 12:49:07 -04001393 u64 bn;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001394
1395 if (!*eablk)
1396 break;
1397 bn = be64_to_cpu(*eablk);
1398
1399 if (bstart + blen == bn)
1400 blen++;
1401 else {
1402 if (bstart)
1403 gfs2_free_meta(ip, bstart, blen);
1404 bstart = bn;
1405 blen = 1;
1406 }
1407
1408 *eablk = 0;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001409 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001410 }
1411 if (bstart)
1412 gfs2_free_meta(ip, bstart, blen);
1413
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001414 ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001415
1416 error = gfs2_meta_inode_buffer(ip, &dibh);
1417 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001418 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001419 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001420 brelse(dibh);
1421 }
1422
1423 gfs2_trans_end(sdp);
1424
Steven Whitehousea91ea692006-09-04 12:04:26 -04001425out_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001426 gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001427out_rlist_free:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001428 gfs2_rlist_free(&rlist);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001429out:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001430 brelse(indbh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001431 return error;
1432}
1433
1434static int ea_dealloc_block(struct gfs2_inode *ip)
1435{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -04001436 struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001437 struct gfs2_rgrpd *rgd;
1438 struct buffer_head *dibh;
Bob Peterson564e12b2011-11-21 13:36:17 -05001439 struct gfs2_holder gh;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001440 int error;
1441
Steven Whitehouse66fc0612012-02-08 12:58:32 +00001442 rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001443 if (!rgd) {
1444 gfs2_consist_inode(ip);
1445 return -EIO;
1446 }
1447
Bob Peterson564e12b2011-11-21 13:36:17 -05001448 error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001449 if (error)
1450 return error;
1451
Steven Whitehousecca195c2006-09-05 13:15:18 -04001452 error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1453 RES_QUOTA, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001454 if (error)
1455 goto out_gunlock;
1456
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001457 gfs2_free_meta(ip, ip->i_eattr, 1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001458
Steven Whitehouse3767ac22008-11-03 14:28:42 +00001459 ip->i_eattr = 0;
Steven Whitehouse77658aa2008-02-12 14:17:27 +00001460 gfs2_add_inode_blocks(&ip->i_inode, -1);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001461
1462 error = gfs2_meta_inode_buffer(ip, &dibh);
1463 if (!error) {
Steven Whitehoused4e9c4c2006-01-18 11:19:28 +00001464 gfs2_trans_add_bh(ip->i_gl, dibh, 1);
Steven Whitehouse539e5d62006-10-31 15:07:05 -05001465 gfs2_dinode_out(ip, dibh->b_data);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001466 brelse(dibh);
1467 }
1468
1469 gfs2_trans_end(sdp);
1470
Steven Whitehousea91ea692006-09-04 12:04:26 -04001471out_gunlock:
Bob Peterson564e12b2011-11-21 13:36:17 -05001472 gfs2_glock_dq_uninit(&gh);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001473 return error;
1474}
1475
1476/**
1477 * gfs2_ea_dealloc - deallocate the extended attribute fork
1478 * @ip: the inode
1479 *
1480 * Returns: errno
1481 */
1482
1483int gfs2_ea_dealloc(struct gfs2_inode *ip)
1484{
Bob Peterson564e12b2011-11-21 13:36:17 -05001485 struct gfs2_qadata *qa;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001486 int error;
1487
Bob Peterson564e12b2011-11-21 13:36:17 -05001488 qa = gfs2_qadata_get(ip);
1489 if (!qa)
Cyrill Gorcunov182fe5a2008-03-03 21:54:21 +03001490 return -ENOMEM;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001491
1492 error = gfs2_quota_hold(ip, NO_QUOTA_CHANGE, NO_QUOTA_CHANGE);
1493 if (error)
1494 goto out_alloc;
1495
David Teiglandb3b94fa2006-01-16 16:50:04 +00001496 error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1497 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001498 goto out_quota;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001499
Steven Whitehouse383f01f2008-11-04 10:05:22 +00001500 if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
David Teiglandb3b94fa2006-01-16 16:50:04 +00001501 error = ea_dealloc_indirect(ip);
1502 if (error)
Steven Whitehouse8339ee52011-08-31 16:38:29 +01001503 goto out_quota;
David Teiglandb3b94fa2006-01-16 16:50:04 +00001504 }
1505
1506 error = ea_dealloc_block(ip);
1507
Steven Whitehousea91ea692006-09-04 12:04:26 -04001508out_quota:
David Teiglandb3b94fa2006-01-16 16:50:04 +00001509 gfs2_quota_unhold(ip);
Steven Whitehousea91ea692006-09-04 12:04:26 -04001510out_alloc:
Bob Peterson564e12b2011-11-21 13:36:17 -05001511 gfs2_qadata_put(ip);
David Teiglandb3b94fa2006-01-16 16:50:04 +00001512 return error;
1513}
1514
Stephen Hemmingerb7bb0a12010-05-13 17:53:23 -07001515static const struct xattr_handler gfs2_xattr_user_handler = {
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001516 .prefix = XATTR_USER_PREFIX,
Christoph Hellwig431547b2009-11-13 09:52:56 +00001517 .flags = GFS2_EATYPE_USR,
1518 .get = gfs2_xattr_get,
1519 .set = gfs2_xattr_set,
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001520};
1521
Stephen Hemmingerb7bb0a12010-05-13 17:53:23 -07001522static const struct xattr_handler gfs2_xattr_security_handler = {
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001523 .prefix = XATTR_SECURITY_PREFIX,
Christoph Hellwig431547b2009-11-13 09:52:56 +00001524 .flags = GFS2_EATYPE_SECURITY,
1525 .get = gfs2_xattr_get,
1526 .set = gfs2_xattr_set,
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001527};
1528
Stephen Hemmingerb7bb0a12010-05-13 17:53:23 -07001529const struct xattr_handler *gfs2_xattr_handlers[] = {
Steven Whitehouse40b78a32009-08-26 18:41:32 +01001530 &gfs2_xattr_user_handler,
1531 &gfs2_xattr_security_handler,
1532 &gfs2_xattr_system_handler,
1533 NULL,
1534};
1535