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