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