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