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