fs/gfs2/eattr.c

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