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