~ [ 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 <linux/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(&ip->i_inode);
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(struct inode *inode, const char *name,
587                             void *buffer, size_t size, int type)
588 {
589         struct gfs2_inode *ip = GFS2_I(inode);
590         struct gfs2_ea_location el;
591         int error;
592 
593         if (!ip->i_eattr)
594                 return -ENODATA;
595         if (strlen(name) > GFS2_EA_MAX_NAME_LEN)
596                 return -EINVAL;
597 
598         error = gfs2_ea_find(ip, type, name, &el);
599         if (error)
600                 return error;
601         if (!el.el_ea)
602                 return -ENODATA;
603         if (size)
604                 error = gfs2_ea_get_copy(ip, &el, buffer, size);
605         else
606                 error = GFS2_EA_DATA_LEN(el.el_ea);
607         brelse(el.el_bh);
608 
609         return error;
610 }
611 
612 static int gfs2_xattr_get(const struct xattr_handler *handler,
613                           struct dentry *unused, struct inode *inode,
614                           const char *name, void *buffer, size_t size)
615 {
616         struct gfs2_inode *ip = GFS2_I(inode);
617         struct gfs2_holder gh;
618         bool need_unlock = false;
619         int ret;
620 
621         /* During lookup, SELinux calls this function with the glock locked. */
622 
623         if (!gfs2_glock_is_locked_by_me(ip->i_gl)) {
624                 ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &gh);
625                 if (ret)
626                         return ret;
627                 need_unlock = true;
628         }
629         ret = __gfs2_xattr_get(inode, name, buffer, size, handler->flags);
630         if (need_unlock)
631                 gfs2_glock_dq_uninit(&gh);
632         return ret;
633 }
634 
635 /**
636  * ea_alloc_blk - allocates a new block for extended attributes.
637  * @ip: A pointer to the inode that's getting extended attributes
638  * @bhp: Pointer to pointer to a struct buffer_head
639  *
640  * Returns: errno
641  */
642 
643 static int ea_alloc_blk(struct gfs2_inode *ip, struct buffer_head **bhp)
644 {
645         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
646         struct gfs2_ea_header *ea;
647         unsigned int n = 1;
648         u64 block;
649         int error;
650 
651         error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
652         if (error)
653                 return error;
654         gfs2_trans_add_unrevoke(sdp, block, 1);
655         *bhp = gfs2_meta_new(ip->i_gl, block);
656         gfs2_trans_add_meta(ip->i_gl, *bhp);
657         gfs2_metatype_set(*bhp, GFS2_METATYPE_EA, GFS2_FORMAT_EA);
658         gfs2_buffer_clear_tail(*bhp, sizeof(struct gfs2_meta_header));
659 
660         ea = GFS2_EA_BH2FIRST(*bhp);
661         ea->ea_rec_len = cpu_to_be32(sdp->sd_jbsize);
662         ea->ea_type = GFS2_EATYPE_UNUSED;
663         ea->ea_flags = GFS2_EAFLAG_LAST;
664         ea->ea_num_ptrs = 0;
665 
666         gfs2_add_inode_blocks(&ip->i_inode, 1);
667 
668         return 0;
669 }
670 
671 /**
672  * ea_write - writes the request info to an ea, creating new blocks if
673  *            necessary
674  * @ip: inode that is being modified
675  * @ea: the location of the new ea in a block
676  * @er: the write request
677  *
678  * Note: does not update ea_rec_len or the GFS2_EAFLAG_LAST bin of ea_flags
679  *
680  * returns : errno
681  */
682 
683 static int ea_write(struct gfs2_inode *ip, struct gfs2_ea_header *ea,
684                     struct gfs2_ea_request *er)
685 {
686         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
687         int error;
688 
689         ea->ea_data_len = cpu_to_be32(er->er_data_len);
690         ea->ea_name_len = er->er_name_len;
691         ea->ea_type = er->er_type;
692         ea->__pad = 0;
693 
694         memcpy(GFS2_EA2NAME(ea), er->er_name, er->er_name_len);
695 
696         if (GFS2_EAREQ_SIZE_STUFFED(er) <= sdp->sd_jbsize) {
697                 ea->ea_num_ptrs = 0;
698                 memcpy(GFS2_EA2DATA(ea), er->er_data, er->er_data_len);
699         } else {
700                 __be64 *dataptr = GFS2_EA2DATAPTRS(ea);
701                 const char *data = er->er_data;
702                 unsigned int data_len = er->er_data_len;
703                 unsigned int copy;
704                 unsigned int x;
705 
706                 ea->ea_num_ptrs = DIV_ROUND_UP(er->er_data_len, sdp->sd_jbsize);
707                 for (x = 0; x < ea->ea_num_ptrs; x++) {
708                         struct buffer_head *bh;
709                         u64 block;
710                         int mh_size = sizeof(struct gfs2_meta_header);
711                         unsigned int n = 1;
712 
713                         error = gfs2_alloc_blocks(ip, &block, &n, 0, NULL);
714                         if (error)
715                                 return error;
716                         gfs2_trans_add_unrevoke(sdp, block, 1);
717                         bh = gfs2_meta_new(ip->i_gl, block);
718                         gfs2_trans_add_meta(ip->i_gl, bh);
719                         gfs2_metatype_set(bh, GFS2_METATYPE_ED, GFS2_FORMAT_ED);
720 
721                         gfs2_add_inode_blocks(&ip->i_inode, 1);
722 
723                         copy = data_len > sdp->sd_jbsize ? sdp->sd_jbsize :
724                                                            data_len;
725                         memcpy(bh->b_data + mh_size, data, copy);
726                         if (copy < sdp->sd_jbsize)
727                                 memset(bh->b_data + mh_size + copy, 0,
728                                        sdp->sd_jbsize - copy);
729 
730                         *dataptr++ = cpu_to_be64(bh->b_blocknr);
731                         data += copy;
732                         data_len -= copy;
733 
734                         brelse(bh);
735                 }
736 
737                 gfs2_assert_withdraw(sdp, !data_len);
738         }
739 
740         return 0;
741 }
742 
743 typedef int (*ea_skeleton_call_t) (struct gfs2_inode *ip,
744                                    struct gfs2_ea_request *er, void *private);
745 
746 static int ea_alloc_skeleton(struct gfs2_inode *ip, struct gfs2_ea_request *er,
747                              unsigned int blks,
748                              ea_skeleton_call_t skeleton_call, void *private)
749 {
750         struct gfs2_alloc_parms ap = { .target = blks };
751         struct buffer_head *dibh;
752         int error;
753 
754         error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));
755         if (error)
756                 return error;
757 
758         error = gfs2_quota_lock_check(ip, &ap);
759         if (error)
760                 return error;
761 
762         error = gfs2_inplace_reserve(ip, &ap);
763         if (error)
764                 goto out_gunlock_q;
765 
766         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode),
767                                  blks + gfs2_rg_blocks(ip, blks) +
768                                  RES_DINODE + RES_STATFS + RES_QUOTA, 0);
769         if (error)
770                 goto out_ipres;
771 
772         error = skeleton_call(ip, er, private);
773         if (error)
774                 goto out_end_trans;
775 
776         error = gfs2_meta_inode_buffer(ip, &dibh);
777         if (!error) {
778                 ip->i_inode.i_ctime = current_time(&ip->i_inode);
779                 gfs2_trans_add_meta(ip->i_gl, dibh);
780                 gfs2_dinode_out(ip, dibh->b_data);
781                 brelse(dibh);
782         }
783 
784 out_end_trans:
785         gfs2_trans_end(GFS2_SB(&ip->i_inode));
786 out_ipres:
787         gfs2_inplace_release(ip);
788 out_gunlock_q:
789         gfs2_quota_unlock(ip);
790         return error;
791 }
792 
793 static int ea_init_i(struct gfs2_inode *ip, struct gfs2_ea_request *er,
794                      void *private)
795 {
796         struct buffer_head *bh;
797         int error;
798 
799         error = ea_alloc_blk(ip, &bh);
800         if (error)
801                 return error;
802 
803         ip->i_eattr = bh->b_blocknr;
804         error = ea_write(ip, GFS2_EA_BH2FIRST(bh), er);
805 
806         brelse(bh);
807 
808         return error;
809 }
810 
811 /**
812  * ea_init - initializes a new eattr block
813  * @ip:
814  * @er:
815  *
816  * Returns: errno
817  */
818 
819 static int ea_init(struct gfs2_inode *ip, int type, const char *name,
820                    const void *data, size_t size)
821 {
822         struct gfs2_ea_request er;
823         unsigned int jbsize = GFS2_SB(&ip->i_inode)->sd_jbsize;
824         unsigned int blks = 1;
825 
826         er.er_type = type;
827         er.er_name = name;
828         er.er_name_len = strlen(name);
829         er.er_data = (void *)data;
830         er.er_data_len = size;
831 
832         if (GFS2_EAREQ_SIZE_STUFFED(&er) > jbsize)
833                 blks += DIV_ROUND_UP(er.er_data_len, jbsize);
834 
835         return ea_alloc_skeleton(ip, &er, blks, ea_init_i, NULL);
836 }
837 
838 static struct gfs2_ea_header *ea_split_ea(struct gfs2_ea_header *ea)
839 {
840         u32 ea_size = GFS2_EA_SIZE(ea);
841         struct gfs2_ea_header *new = (struct gfs2_ea_header *)((char *)ea +
842                                      ea_size);
843         u32 new_size = GFS2_EA_REC_LEN(ea) - ea_size;
844         int last = ea->ea_flags & GFS2_EAFLAG_LAST;
845 
846         ea->ea_rec_len = cpu_to_be32(ea_size);
847         ea->ea_flags ^= last;
848 
849         new->ea_rec_len = cpu_to_be32(new_size);
850         new->ea_flags = last;
851 
852         return new;
853 }
854 
855 static void ea_set_remove_stuffed(struct gfs2_inode *ip,
856                                   struct gfs2_ea_location *el)
857 {
858         struct gfs2_ea_header *ea = el->el_ea;
859         struct gfs2_ea_header *prev = el->el_prev;
860         u32 len;
861 
862         gfs2_trans_add_meta(ip->i_gl, el->el_bh);
863 
864         if (!prev || !GFS2_EA_IS_STUFFED(ea)) {
865                 ea->ea_type = GFS2_EATYPE_UNUSED;
866                 return;
867         } else if (GFS2_EA2NEXT(prev) != ea) {
868                 prev = GFS2_EA2NEXT(prev);
869                 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode), GFS2_EA2NEXT(prev) == ea);
870         }
871 
872         len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
873         prev->ea_rec_len = cpu_to_be32(len);
874 
875         if (GFS2_EA_IS_LAST(ea))
876                 prev->ea_flags |= GFS2_EAFLAG_LAST;
877 }
878 
879 struct ea_set {
880         int ea_split;
881 
882         struct gfs2_ea_request *es_er;
883         struct gfs2_ea_location *es_el;
884 
885         struct buffer_head *es_bh;
886         struct gfs2_ea_header *es_ea;
887 };
888 
889 static int ea_set_simple_noalloc(struct gfs2_inode *ip, struct buffer_head *bh,
890                                  struct gfs2_ea_header *ea, struct ea_set *es)
891 {
892         struct gfs2_ea_request *er = es->es_er;
893         struct buffer_head *dibh;
894         int error;
895 
896         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + 2 * RES_EATTR, 0);
897         if (error)
898                 return error;
899 
900         gfs2_trans_add_meta(ip->i_gl, bh);
901 
902         if (es->ea_split)
903                 ea = ea_split_ea(ea);
904 
905         ea_write(ip, ea, er);
906 
907         if (es->es_el)
908                 ea_set_remove_stuffed(ip, es->es_el);
909 
910         error = gfs2_meta_inode_buffer(ip, &dibh);
911         if (error)
912                 goto out;
913         ip->i_inode.i_ctime = current_time(&ip->i_inode);
914         gfs2_trans_add_meta(ip->i_gl, dibh);
915         gfs2_dinode_out(ip, dibh->b_data);
916         brelse(dibh);
917 out:
918         gfs2_trans_end(GFS2_SB(&ip->i_inode));
919         return error;
920 }
921 
922 static int ea_set_simple_alloc(struct gfs2_inode *ip,
923                                struct gfs2_ea_request *er, void *private)
924 {
925         struct ea_set *es = private;
926         struct gfs2_ea_header *ea = es->es_ea;
927         int error;
928 
929         gfs2_trans_add_meta(ip->i_gl, es->es_bh);
930 
931         if (es->ea_split)
932                 ea = ea_split_ea(ea);
933 
934         error = ea_write(ip, ea, er);
935         if (error)
936                 return error;
937 
938         if (es->es_el)
939                 ea_set_remove_stuffed(ip, es->es_el);
940 
941         return 0;
942 }
943 
944 static int ea_set_simple(struct gfs2_inode *ip, struct buffer_head *bh,
945                          struct gfs2_ea_header *ea, struct gfs2_ea_header *prev,
946                          void *private)
947 {
948         struct ea_set *es = private;
949         unsigned int size;
950         int stuffed;
951         int error;
952 
953         stuffed = ea_calc_size(GFS2_SB(&ip->i_inode), es->es_er->er_name_len,
954                                es->es_er->er_data_len, &size);
955 
956         if (ea->ea_type == GFS2_EATYPE_UNUSED) {
957                 if (GFS2_EA_REC_LEN(ea) < size)
958                         return 0;
959                 if (!GFS2_EA_IS_STUFFED(ea)) {
960                         error = ea_remove_unstuffed(ip, bh, ea, prev, 1);
961                         if (error)
962                                 return error;
963                 }
964                 es->ea_split = 0;
965         } else if (GFS2_EA_REC_LEN(ea) - GFS2_EA_SIZE(ea) >= size)
966                 es->ea_split = 1;
967         else
968                 return 0;
969 
970         if (stuffed) {
971                 error = ea_set_simple_noalloc(ip, bh, ea, es);
972                 if (error)
973                         return error;
974         } else {
975                 unsigned int blks;
976 
977                 es->es_bh = bh;
978                 es->es_ea = ea;
979                 blks = 2 + DIV_ROUND_UP(es->es_er->er_data_len,
980                                         GFS2_SB(&ip->i_inode)->sd_jbsize);
981 
982                 error = ea_alloc_skeleton(ip, es->es_er, blks,
983                                           ea_set_simple_alloc, es);
984                 if (error)
985                         return error;
986         }
987 
988         return 1;
989 }
990 
991 static int ea_set_block(struct gfs2_inode *ip, struct gfs2_ea_request *er,
992                         void *private)
993 {
994         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
995         struct buffer_head *indbh, *newbh;
996         __be64 *eablk;
997         int error;
998         int mh_size = sizeof(struct gfs2_meta_header);
999 
1000         if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
1001                 __be64 *end;
1002 
1003                 error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, 0,
1004                                        &indbh);
1005                 if (error)
1006                         return error;
1007 
1008                 if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1009                         error = -EIO;
1010                         goto out;
1011                 }
1012 
1013                 eablk = (__be64 *)(indbh->b_data + mh_size);
1014                 end = eablk + sdp->sd_inptrs;
1015 
1016                 for (; eablk < end; eablk++)
1017                         if (!*eablk)
1018                                 break;
1019 
1020                 if (eablk == end) {
1021                         error = -ENOSPC;
1022                         goto out;
1023                 }
1024 
1025                 gfs2_trans_add_meta(ip->i_gl, indbh);
1026         } else {
1027                 u64 blk;
1028                 unsigned int n = 1;
1029                 error = gfs2_alloc_blocks(ip, &blk, &n, 0, NULL);
1030                 if (error)
1031                         return error;
1032                 gfs2_trans_add_unrevoke(sdp, blk, 1);
1033                 indbh = gfs2_meta_new(ip->i_gl, blk);
1034                 gfs2_trans_add_meta(ip->i_gl, indbh);
1035                 gfs2_metatype_set(indbh, GFS2_METATYPE_IN, GFS2_FORMAT_IN);
1036                 gfs2_buffer_clear_tail(indbh, mh_size);
1037 
1038                 eablk = (__be64 *)(indbh->b_data + mh_size);
1039                 *eablk = cpu_to_be64(ip->i_eattr);
1040                 ip->i_eattr = blk;
1041                 ip->i_diskflags |= GFS2_DIF_EA_INDIRECT;
1042                 gfs2_add_inode_blocks(&ip->i_inode, 1);
1043 
1044                 eablk++;
1045         }
1046 
1047         error = ea_alloc_blk(ip, &newbh);
1048         if (error)
1049                 goto out;
1050 
1051         *eablk = cpu_to_be64((u64)newbh->b_blocknr);
1052         error = ea_write(ip, GFS2_EA_BH2FIRST(newbh), er);
1053         brelse(newbh);
1054         if (error)
1055                 goto out;
1056 
1057         if (private)
1058                 ea_set_remove_stuffed(ip, private);
1059 
1060 out:
1061         brelse(indbh);
1062         return error;
1063 }
1064 
1065 static int ea_set_i(struct gfs2_inode *ip, int type, const char *name,
1066                     const void *value, size_t size, struct gfs2_ea_location *el)
1067 {
1068         struct gfs2_ea_request er;
1069         struct ea_set es;
1070         unsigned int blks = 2;
1071         int error;
1072 
1073         er.er_type = type;
1074         er.er_name = name;
1075         er.er_data = (void *)value;
1076         er.er_name_len = strlen(name);
1077         er.er_data_len = size;
1078 
1079         memset(&es, 0, sizeof(struct ea_set));
1080         es.es_er = &er;
1081         es.es_el = el;
1082 
1083         error = ea_foreach(ip, ea_set_simple, &es);
1084         if (error > 0)
1085                 return 0;
1086         if (error)
1087                 return error;
1088 
1089         if (!(ip->i_diskflags & GFS2_DIF_EA_INDIRECT))
1090                 blks++;
1091         if (GFS2_EAREQ_SIZE_STUFFED(&er) > GFS2_SB(&ip->i_inode)->sd_jbsize)
1092                 blks += DIV_ROUND_UP(er.er_data_len, GFS2_SB(&ip->i_inode)->sd_jbsize);
1093 
1094         return ea_alloc_skeleton(ip, &er, blks, ea_set_block, el);
1095 }
1096 
1097 static int ea_set_remove_unstuffed(struct gfs2_inode *ip,
1098                                    struct gfs2_ea_location *el)
1099 {
1100         if (el->el_prev && GFS2_EA2NEXT(el->el_prev) != el->el_ea) {
1101                 el->el_prev = GFS2_EA2NEXT(el->el_prev);
1102                 gfs2_assert_withdraw(GFS2_SB(&ip->i_inode),
1103                                      GFS2_EA2NEXT(el->el_prev) == el->el_ea);
1104         }
1105 
1106         return ea_remove_unstuffed(ip, el->el_bh, el->el_ea, el->el_prev, 0);
1107 }
1108 
1109 static int ea_remove_stuffed(struct gfs2_inode *ip, struct gfs2_ea_location *el)
1110 {
1111         struct gfs2_ea_header *ea = el->el_ea;
1112         struct gfs2_ea_header *prev = el->el_prev;
1113         struct buffer_head *dibh;
1114         int error;
1115 
1116         error = gfs2_trans_begin(GFS2_SB(&ip->i_inode), RES_DINODE + RES_EATTR, 0);
1117         if (error)
1118                 return error;
1119 
1120         gfs2_trans_add_meta(ip->i_gl, el->el_bh);
1121 
1122         if (prev) {
1123                 u32 len;
1124 
1125                 len = GFS2_EA_REC_LEN(prev) + GFS2_EA_REC_LEN(ea);
1126                 prev->ea_rec_len = cpu_to_be32(len);
1127 
1128                 if (GFS2_EA_IS_LAST(ea))
1129                         prev->ea_flags |= GFS2_EAFLAG_LAST;
1130         } else {
1131                 ea->ea_type = GFS2_EATYPE_UNUSED;
1132         }
1133 
1134         error = gfs2_meta_inode_buffer(ip, &dibh);
1135         if (!error) {
1136                 ip->i_inode.i_ctime = current_time(&ip->i_inode);
1137                 gfs2_trans_add_meta(ip->i_gl, dibh);
1138                 gfs2_dinode_out(ip, dibh->b_data);
1139                 brelse(dibh);
1140         }
1141 
1142         gfs2_trans_end(GFS2_SB(&ip->i_inode));
1143 
1144         return error;
1145 }
1146 
1147 /**
1148  * gfs2_xattr_remove - Remove a GFS2 extended attribute
1149  * @ip: The inode
1150  * @type: The type of the extended attribute
1151  * @name: The name of the extended attribute
1152  *
1153  * This is not called directly by the VFS since we use the (common)
1154  * scheme of making a "set with NULL data" mean a remove request. Note
1155  * that this is different from a set with zero length data.
1156  *
1157  * Returns: 0, or errno on failure
1158  */
1159 
1160 static int gfs2_xattr_remove(struct gfs2_inode *ip, int type, const char *name)
1161 {
1162         struct gfs2_ea_location el;
1163         int error;
1164 
1165         if (!ip->i_eattr)
1166                 return -ENODATA;
1167 
1168         error = gfs2_ea_find(ip, type, name, &el);
1169         if (error)
1170                 return error;
1171         if (!el.el_ea)
1172                 return -ENODATA;
1173 
1174         if (GFS2_EA_IS_STUFFED(el.el_ea))
1175                 error = ea_remove_stuffed(ip, &el);
1176         else
1177                 error = ea_remove_unstuffed(ip, el.el_bh, el.el_ea, el.el_prev, 0);
1178 
1179         brelse(el.el_bh);
1180 
1181         return error;
1182 }
1183 
1184 /**
1185  * __gfs2_xattr_set - Set (or remove) a GFS2 extended attribute
1186  * @ip: The inode
1187  * @name: The name of the extended attribute
1188  * @value: The value of the extended attribute (NULL for remove)
1189  * @size: The size of the @value argument
1190  * @flags: Create or Replace
1191  * @type: The type of the extended attribute
1192  *
1193  * See gfs2_xattr_remove() for details of the removal of xattrs.
1194  *
1195  * Returns: 0 or errno on failure
1196  */
1197 
1198 int __gfs2_xattr_set(struct inode *inode, const char *name,
1199                    const void *value, size_t size, int flags, int type)
1200 {
1201         struct gfs2_inode *ip = GFS2_I(inode);
1202         struct gfs2_sbd *sdp = GFS2_SB(inode);
1203         struct gfs2_ea_location el;
1204         unsigned int namel = strlen(name);
1205         int error;
1206 
1207         if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
1208                 return -EPERM;
1209         if (namel > GFS2_EA_MAX_NAME_LEN)
1210                 return -ERANGE;
1211 
1212         if (value == NULL)
1213                 return gfs2_xattr_remove(ip, type, name);
1214 
1215         if (ea_check_size(sdp, namel, size))
1216                 return -ERANGE;
1217 
1218         if (!ip->i_eattr) {
1219                 if (flags & XATTR_REPLACE)
1220                         return -ENODATA;
1221                 return ea_init(ip, type, name, value, size);
1222         }
1223 
1224         error = gfs2_ea_find(ip, type, name, &el);
1225         if (error)
1226                 return error;
1227 
1228         if (el.el_ea) {
1229                 if (ip->i_diskflags & GFS2_DIF_APPENDONLY) {
1230                         brelse(el.el_bh);
1231                         return -EPERM;
1232                 }
1233 
1234                 error = -EEXIST;
1235                 if (!(flags & XATTR_CREATE)) {
1236                         int unstuffed = !GFS2_EA_IS_STUFFED(el.el_ea);
1237                         error = ea_set_i(ip, type, name, value, size, &el);
1238                         if (!error && unstuffed)
1239                                 ea_set_remove_unstuffed(ip, &el);
1240                 }
1241 
1242                 brelse(el.el_bh);
1243                 return error;
1244         }
1245 
1246         error = -ENODATA;
1247         if (!(flags & XATTR_REPLACE))
1248                 error = ea_set_i(ip, type, name, value, size, NULL);
1249 
1250         return error;
1251 }
1252 
1253 static int gfs2_xattr_set(const struct xattr_handler *handler,
1254                           struct dentry *unused, struct inode *inode,
1255                           const char *name, const void *value,
1256                           size_t size, int flags)
1257 {
1258         struct gfs2_inode *ip = GFS2_I(inode);
1259         struct gfs2_holder gh;
1260         int ret;
1261 
1262         ret = gfs2_rsqa_alloc(ip);
1263         if (ret)
1264                 return ret;
1265 
1266         ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
1267         if (ret)
1268                 return ret;
1269         ret = __gfs2_xattr_set(inode, name, value, size, flags, handler->flags);
1270         gfs2_glock_dq_uninit(&gh);
1271         return ret;
1272 }
1273 
1274 static int ea_dealloc_indirect(struct gfs2_inode *ip)
1275 {
1276         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1277         struct gfs2_rgrp_list rlist;
1278         struct buffer_head *indbh, *dibh;
1279         __be64 *eablk, *end;
1280         unsigned int rg_blocks = 0;
1281         u64 bstart = 0;
1282         unsigned int blen = 0;
1283         unsigned int blks = 0;
1284         unsigned int x;
1285         int error;
1286 
1287         error = gfs2_rindex_update(sdp);
1288         if (error)
1289                 return error;
1290 
1291         memset(&rlist, 0, sizeof(struct gfs2_rgrp_list));
1292 
1293         error = gfs2_meta_read(ip->i_gl, ip->i_eattr, DIO_WAIT, 0, &indbh);
1294         if (error)
1295                 return error;
1296 
1297         if (gfs2_metatype_check(sdp, indbh, GFS2_METATYPE_IN)) {
1298                 error = -EIO;
1299                 goto out;
1300         }
1301 
1302         eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1303         end = eablk + sdp->sd_inptrs;
1304 
1305         for (; eablk < end; eablk++) {
1306                 u64 bn;
1307 
1308                 if (!*eablk)
1309                         break;
1310                 bn = be64_to_cpu(*eablk);
1311 
1312                 if (bstart + blen == bn)
1313                         blen++;
1314                 else {
1315                         if (bstart)
1316                                 gfs2_rlist_add(ip, &rlist, bstart);
1317                         bstart = bn;
1318                         blen = 1;
1319                 }
1320                 blks++;
1321         }
1322         if (bstart)
1323                 gfs2_rlist_add(ip, &rlist, bstart);
1324         else
1325                 goto out;
1326 
1327         gfs2_rlist_alloc(&rlist, LM_ST_EXCLUSIVE);
1328 
1329         for (x = 0; x < rlist.rl_rgrps; x++) {
1330                 struct gfs2_rgrpd *rgd;
1331                 rgd = rlist.rl_ghs[x].gh_gl->gl_object;
1332                 rg_blocks += rgd->rd_length;
1333         }
1334 
1335         error = gfs2_glock_nq_m(rlist.rl_rgrps, rlist.rl_ghs);
1336         if (error)
1337                 goto out_rlist_free;
1338 
1339         error = gfs2_trans_begin(sdp, rg_blocks + RES_DINODE + RES_INDIRECT +
1340                                  RES_STATFS + RES_QUOTA, blks);
1341         if (error)
1342                 goto out_gunlock;
1343 
1344         gfs2_trans_add_meta(ip->i_gl, indbh);
1345 
1346         eablk = (__be64 *)(indbh->b_data + sizeof(struct gfs2_meta_header));
1347         bstart = 0;
1348         blen = 0;
1349 
1350         for (; eablk < end; eablk++) {
1351                 u64 bn;
1352 
1353                 if (!*eablk)
1354                         break;
1355                 bn = be64_to_cpu(*eablk);
1356 
1357                 if (bstart + blen == bn)
1358                         blen++;
1359                 else {
1360                         if (bstart)
1361                                 gfs2_free_meta(ip, bstart, blen);
1362                         bstart = bn;
1363                         blen = 1;
1364                 }
1365 
1366                 *eablk = 0;
1367                 gfs2_add_inode_blocks(&ip->i_inode, -1);
1368         }
1369         if (bstart)
1370                 gfs2_free_meta(ip, bstart, blen);
1371 
1372         ip->i_diskflags &= ~GFS2_DIF_EA_INDIRECT;
1373 
1374         error = gfs2_meta_inode_buffer(ip, &dibh);
1375         if (!error) {
1376                 gfs2_trans_add_meta(ip->i_gl, dibh);
1377                 gfs2_dinode_out(ip, dibh->b_data);
1378                 brelse(dibh);
1379         }
1380 
1381         gfs2_trans_end(sdp);
1382 
1383 out_gunlock:
1384         gfs2_glock_dq_m(rlist.rl_rgrps, rlist.rl_ghs);
1385 out_rlist_free:
1386         gfs2_rlist_free(&rlist);
1387 out:
1388         brelse(indbh);
1389         return error;
1390 }
1391 
1392 static int ea_dealloc_block(struct gfs2_inode *ip)
1393 {
1394         struct gfs2_sbd *sdp = GFS2_SB(&ip->i_inode);
1395         struct gfs2_rgrpd *rgd;
1396         struct buffer_head *dibh;
1397         struct gfs2_holder gh;
1398         int error;
1399 
1400         error = gfs2_rindex_update(sdp);
1401         if (error)
1402                 return error;
1403 
1404         rgd = gfs2_blk2rgrpd(sdp, ip->i_eattr, 1);
1405         if (!rgd) {
1406                 gfs2_consist_inode(ip);
1407                 return -EIO;
1408         }
1409 
1410         error = gfs2_glock_nq_init(rgd->rd_gl, LM_ST_EXCLUSIVE, 0, &gh);
1411         if (error)
1412                 return error;
1413 
1414         error = gfs2_trans_begin(sdp, RES_RG_BIT + RES_DINODE + RES_STATFS +
1415                                  RES_QUOTA, 1);
1416         if (error)
1417                 goto out_gunlock;
1418 
1419         gfs2_free_meta(ip, ip->i_eattr, 1);
1420 
1421         ip->i_eattr = 0;
1422         gfs2_add_inode_blocks(&ip->i_inode, -1);
1423 
1424         error = gfs2_meta_inode_buffer(ip, &dibh);
1425         if (!error) {
1426                 gfs2_trans_add_meta(ip->i_gl, dibh);
1427                 gfs2_dinode_out(ip, dibh->b_data);
1428                 brelse(dibh);
1429         }
1430 
1431         gfs2_trans_end(sdp);
1432 
1433 out_gunlock:
1434         gfs2_glock_dq_uninit(&gh);
1435         return error;
1436 }
1437 
1438 /**
1439  * gfs2_ea_dealloc - deallocate the extended attribute fork
1440  * @ip: the inode
1441  *
1442  * Returns: errno
1443  */
1444 
1445 int gfs2_ea_dealloc(struct gfs2_inode *ip)
1446 {
1447         int error;
1448 
1449         error = gfs2_rindex_update(GFS2_SB(&ip->i_inode));
1450         if (error)
1451                 return error;
1452 
1453         error = gfs2_quota_hold(ip, NO_UID_QUOTA_CHANGE, NO_GID_QUOTA_CHANGE);
1454         if (error)
1455                 return error;
1456 
1457         error = ea_foreach(ip, ea_dealloc_unstuffed, NULL);
1458         if (error)
1459                 goto out_quota;
1460 
1461         if (ip->i_diskflags & GFS2_DIF_EA_INDIRECT) {
1462                 error = ea_dealloc_indirect(ip);
1463                 if (error)
1464                         goto out_quota;
1465         }
1466 
1467         error = ea_dealloc_block(ip);
1468 
1469 out_quota:
1470         gfs2_quota_unhold(ip);
1471         return error;
1472 }
1473 
1474 static const struct xattr_handler gfs2_xattr_user_handler = {
1475         .prefix = XATTR_USER_PREFIX,
1476         .flags  = GFS2_EATYPE_USR,
1477         .get    = gfs2_xattr_get,
1478         .set    = gfs2_xattr_set,
1479 };
1480 
1481 static const struct xattr_handler gfs2_xattr_security_handler = {
1482         .prefix = XATTR_SECURITY_PREFIX,
1483         .flags  = GFS2_EATYPE_SECURITY,
1484         .get    = gfs2_xattr_get,
1485         .set    = gfs2_xattr_set,
1486 };
1487 
1488 const struct xattr_handler *gfs2_xattr_handlers[] = {
1489         &gfs2_xattr_user_handler,
1490         &gfs2_xattr_security_handler,
1491         &posix_acl_access_xattr_handler,
1492         &posix_acl_default_xattr_handler,
1493         NULL,
1494 };
1495 
1496 

~ [ 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