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