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