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