~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/gfs2/xattr.c

Version: ~ [ linux-5.4-rc7 ] ~ [ linux-5.3.11 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.84 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.154 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.201 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.201 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.77 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp