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