1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * linux/fs/reiserfs/xattr.c 4 * 5 * Copyright (c) 2002 by Jeff Mahoney, <jeffm@suse.com> 6 * 7 */ 8 9 /* 10 * In order to implement EA/ACLs in a clean, backwards compatible manner, 11 * they are implemented as files in a "private" directory. 12 * Each EA is in it's own file, with the directory layout like so (/ is assumed 13 * to be relative to fs root). Inside the /.reiserfs_priv/xattrs directory, 14 * directories named using the capital-hex form of the objectid and 15 * generation number are used. Inside each directory are individual files 16 * named with the name of the extended attribute. 17 * 18 * So, for objectid 12648430, we could have: 19 * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_access 20 * /.reiserfs_priv/xattrs/C0FFEE.0/system.posix_acl_default 21 * /.reiserfs_priv/xattrs/C0FFEE.0/user.Content-Type 22 * .. or similar. 23 * 24 * The file contents are the text of the EA. The size is known based on the 25 * stat data describing the file. 26 * 27 * In the case of system.posix_acl_access and system.posix_acl_default, since 28 * these are special cases for filesystem ACLs, they are interpreted by the 29 * kernel, in addition, they are negatively and positively cached and attached 30 * to the inode so that unnecessary lookups are avoided. 31 * 32 * Locking works like so: 33 * Directory components (xattr root, xattr dir) are protectd by their i_mutex. 34 * The xattrs themselves are protected by the xattr_sem. 35 */ 36 37 #include "reiserfs.h" 38 #include <linux/capability.h> 39 #include <linux/dcache.h> 40 #include <linux/namei.h> 41 #include <linux/errno.h> 42 #include <linux/gfp.h> 43 #include <linux/fs.h> 44 #include <linux/file.h> 45 #include <linux/pagemap.h> 46 #include <linux/xattr.h> 47 #include "xattr.h" 48 #include "acl.h" 49 #include <linux/uaccess.h> 50 #include <net/checksum.h> 51 #include <linux/stat.h> 52 #include <linux/quotaops.h> 53 #include <linux/security.h> 54 #include <linux/posix_acl_xattr.h> 55 56 #define PRIVROOT_NAME ".reiserfs_priv" 57 #define XAROOT_NAME "xattrs" 58 59 60 /* 61 * Helpers for inode ops. We do this so that we don't have all the VFS 62 * overhead and also for proper i_mutex annotation. 63 * dir->i_mutex must be held for all of them. 64 */ 65 #ifdef CONFIG_REISERFS_FS_XATTR 66 static int xattr_create(struct inode *dir, struct dentry *dentry, int mode) 67 { 68 BUG_ON(!inode_is_locked(dir)); 69 return dir->i_op->create(dir, dentry, mode, true); 70 } 71 #endif 72 73 static int xattr_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode) 74 { 75 BUG_ON(!inode_is_locked(dir)); 76 return dir->i_op->mkdir(dir, dentry, mode); 77 } 78 79 /* 80 * We use I_MUTEX_CHILD here to silence lockdep. It's safe because xattr 81 * mutation ops aren't called during rename or splace, which are the 82 * only other users of I_MUTEX_CHILD. It violates the ordering, but that's 83 * better than allocating another subclass just for this code. 84 */ 85 static int xattr_unlink(struct inode *dir, struct dentry *dentry) 86 { 87 int error; 88 89 BUG_ON(!inode_is_locked(dir)); 90 91 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD); 92 error = dir->i_op->unlink(dir, dentry); 93 inode_unlock(d_inode(dentry)); 94 95 if (!error) 96 d_delete(dentry); 97 return error; 98 } 99 100 static int xattr_rmdir(struct inode *dir, struct dentry *dentry) 101 { 102 int error; 103 104 BUG_ON(!inode_is_locked(dir)); 105 106 inode_lock_nested(d_inode(dentry), I_MUTEX_CHILD); 107 error = dir->i_op->rmdir(dir, dentry); 108 if (!error) 109 d_inode(dentry)->i_flags |= S_DEAD; 110 inode_unlock(d_inode(dentry)); 111 if (!error) 112 d_delete(dentry); 113 114 return error; 115 } 116 117 #define xattr_may_create(flags) (!flags || flags & XATTR_CREATE) 118 119 static struct dentry *open_xa_root(struct super_block *sb, int flags) 120 { 121 struct dentry *privroot = REISERFS_SB(sb)->priv_root; 122 struct dentry *xaroot; 123 124 if (d_really_is_negative(privroot)) 125 return ERR_PTR(-ENODATA); 126 127 inode_lock_nested(d_inode(privroot), I_MUTEX_XATTR); 128 129 xaroot = dget(REISERFS_SB(sb)->xattr_root); 130 if (!xaroot) 131 xaroot = ERR_PTR(-ENODATA); 132 else if (d_really_is_negative(xaroot)) { 133 int err = -ENODATA; 134 135 if (xattr_may_create(flags)) 136 err = xattr_mkdir(d_inode(privroot), xaroot, 0700); 137 if (err) { 138 dput(xaroot); 139 xaroot = ERR_PTR(err); 140 } 141 } 142 143 inode_unlock(d_inode(privroot)); 144 return xaroot; 145 } 146 147 static struct dentry *open_xa_dir(const struct inode *inode, int flags) 148 { 149 struct dentry *xaroot, *xadir; 150 char namebuf[17]; 151 152 xaroot = open_xa_root(inode->i_sb, flags); 153 if (IS_ERR(xaroot)) 154 return xaroot; 155 156 snprintf(namebuf, sizeof(namebuf), "%X.%X", 157 le32_to_cpu(INODE_PKEY(inode)->k_objectid), 158 inode->i_generation); 159 160 inode_lock_nested(d_inode(xaroot), I_MUTEX_XATTR); 161 162 xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf)); 163 if (!IS_ERR(xadir) && d_really_is_negative(xadir)) { 164 int err = -ENODATA; 165 166 if (xattr_may_create(flags)) 167 err = xattr_mkdir(d_inode(xaroot), xadir, 0700); 168 if (err) { 169 dput(xadir); 170 xadir = ERR_PTR(err); 171 } 172 } 173 174 inode_unlock(d_inode(xaroot)); 175 dput(xaroot); 176 return xadir; 177 } 178 179 /* 180 * The following are side effects of other operations that aren't explicitly 181 * modifying extended attributes. This includes operations such as permissions 182 * or ownership changes, object deletions, etc. 183 */ 184 struct reiserfs_dentry_buf { 185 struct dir_context ctx; 186 struct dentry *xadir; 187 int count; 188 struct dentry *dentries[8]; 189 }; 190 191 static int 192 fill_with_dentries(struct dir_context *ctx, const char *name, int namelen, 193 loff_t offset, u64 ino, unsigned int d_type) 194 { 195 struct reiserfs_dentry_buf *dbuf = 196 container_of(ctx, struct reiserfs_dentry_buf, ctx); 197 struct dentry *dentry; 198 199 WARN_ON_ONCE(!inode_is_locked(d_inode(dbuf->xadir))); 200 201 if (dbuf->count == ARRAY_SIZE(dbuf->dentries)) 202 return -ENOSPC; 203 204 if (name[0] == '.' && (namelen < 2 || 205 (namelen == 2 && name[1] == '.'))) 206 return 0; 207 208 dentry = lookup_one_len(name, dbuf->xadir, namelen); 209 if (IS_ERR(dentry)) { 210 return PTR_ERR(dentry); 211 } else if (d_really_is_negative(dentry)) { 212 /* A directory entry exists, but no file? */ 213 reiserfs_error(dentry->d_sb, "xattr-20003", 214 "Corrupted directory: xattr %pd listed but " 215 "not found for file %pd.\n", 216 dentry, dbuf->xadir); 217 dput(dentry); 218 return -EIO; 219 } 220 221 dbuf->dentries[dbuf->count++] = dentry; 222 return 0; 223 } 224 225 static void 226 cleanup_dentry_buf(struct reiserfs_dentry_buf *buf) 227 { 228 int i; 229 230 for (i = 0; i < buf->count; i++) 231 if (buf->dentries[i]) 232 dput(buf->dentries[i]); 233 } 234 235 static int reiserfs_for_each_xattr(struct inode *inode, 236 int (*action)(struct dentry *, void *), 237 void *data) 238 { 239 struct dentry *dir; 240 int i, err = 0; 241 struct reiserfs_dentry_buf buf = { 242 .ctx.actor = fill_with_dentries, 243 }; 244 245 /* Skip out, an xattr has no xattrs associated with it */ 246 if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1) 247 return 0; 248 249 dir = open_xa_dir(inode, XATTR_REPLACE); 250 if (IS_ERR(dir)) { 251 err = PTR_ERR(dir); 252 goto out; 253 } else if (d_really_is_negative(dir)) { 254 err = 0; 255 goto out_dir; 256 } 257 258 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR); 259 260 buf.xadir = dir; 261 while (1) { 262 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 263 if (err) 264 break; 265 if (!buf.count) 266 break; 267 for (i = 0; !err && i < buf.count && buf.dentries[i]; i++) { 268 struct dentry *dentry = buf.dentries[i]; 269 270 if (!d_is_dir(dentry)) 271 err = action(dentry, data); 272 273 dput(dentry); 274 buf.dentries[i] = NULL; 275 } 276 if (err) 277 break; 278 buf.count = 0; 279 } 280 inode_unlock(d_inode(dir)); 281 282 cleanup_dentry_buf(&buf); 283 284 if (!err) { 285 /* 286 * We start a transaction here to avoid a ABBA situation 287 * between the xattr root's i_mutex and the journal lock. 288 * This doesn't incur much additional overhead since the 289 * new transaction will just nest inside the 290 * outer transaction. 291 */ 292 int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 293 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); 294 struct reiserfs_transaction_handle th; 295 296 reiserfs_write_lock(inode->i_sb); 297 err = journal_begin(&th, inode->i_sb, blocks); 298 reiserfs_write_unlock(inode->i_sb); 299 if (!err) { 300 int jerror; 301 302 inode_lock_nested(d_inode(dir->d_parent), 303 I_MUTEX_XATTR); 304 err = action(dir, data); 305 reiserfs_write_lock(inode->i_sb); 306 jerror = journal_end(&th); 307 reiserfs_write_unlock(inode->i_sb); 308 inode_unlock(d_inode(dir->d_parent)); 309 err = jerror ?: err; 310 } 311 } 312 out_dir: 313 dput(dir); 314 out: 315 /* -ENODATA isn't an error */ 316 if (err == -ENODATA) 317 err = 0; 318 return err; 319 } 320 321 static int delete_one_xattr(struct dentry *dentry, void *data) 322 { 323 struct inode *dir = d_inode(dentry->d_parent); 324 325 /* This is the xattr dir, handle specially. */ 326 if (d_is_dir(dentry)) 327 return xattr_rmdir(dir, dentry); 328 329 return xattr_unlink(dir, dentry); 330 } 331 332 static int chown_one_xattr(struct dentry *dentry, void *data) 333 { 334 struct iattr *attrs = data; 335 int ia_valid = attrs->ia_valid; 336 int err; 337 338 /* 339 * We only want the ownership bits. Otherwise, we'll do 340 * things like change a directory to a regular file if 341 * ATTR_MODE is set. 342 */ 343 attrs->ia_valid &= (ATTR_UID|ATTR_GID); 344 err = reiserfs_setattr(dentry, attrs); 345 attrs->ia_valid = ia_valid; 346 347 return err; 348 } 349 350 /* No i_mutex, but the inode is unconnected. */ 351 int reiserfs_delete_xattrs(struct inode *inode) 352 { 353 int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL); 354 355 if (err) 356 reiserfs_warning(inode->i_sb, "jdm-20004", 357 "Couldn't delete all xattrs (%d)\n", err); 358 return err; 359 } 360 361 /* inode->i_mutex: down */ 362 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs) 363 { 364 int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs); 365 366 if (err) 367 reiserfs_warning(inode->i_sb, "jdm-20007", 368 "Couldn't chown all xattrs (%d)\n", err); 369 return err; 370 } 371 372 #ifdef CONFIG_REISERFS_FS_XATTR 373 /* 374 * Returns a dentry corresponding to a specific extended attribute file 375 * for the inode. If flags allow, the file is created. Otherwise, a 376 * valid or negative dentry, or an error is returned. 377 */ 378 static struct dentry *xattr_lookup(struct inode *inode, const char *name, 379 int flags) 380 { 381 struct dentry *xadir, *xafile; 382 int err = 0; 383 384 xadir = open_xa_dir(inode, flags); 385 if (IS_ERR(xadir)) 386 return ERR_CAST(xadir); 387 388 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR); 389 xafile = lookup_one_len(name, xadir, strlen(name)); 390 if (IS_ERR(xafile)) { 391 err = PTR_ERR(xafile); 392 goto out; 393 } 394 395 if (d_really_is_positive(xafile) && (flags & XATTR_CREATE)) 396 err = -EEXIST; 397 398 if (d_really_is_negative(xafile)) { 399 err = -ENODATA; 400 if (xattr_may_create(flags)) 401 err = xattr_create(d_inode(xadir), xafile, 402 0700|S_IFREG); 403 } 404 405 if (err) 406 dput(xafile); 407 out: 408 inode_unlock(d_inode(xadir)); 409 dput(xadir); 410 if (err) 411 return ERR_PTR(err); 412 return xafile; 413 } 414 415 /* Internal operations on file data */ 416 static inline void reiserfs_put_page(struct page *page) 417 { 418 kunmap(page); 419 put_page(page); 420 } 421 422 static struct page *reiserfs_get_page(struct inode *dir, size_t n) 423 { 424 struct address_space *mapping = dir->i_mapping; 425 struct page *page; 426 /* 427 * We can deadlock if we try to free dentries, 428 * and an unlink/rmdir has just occurred - GFP_NOFS avoids this 429 */ 430 mapping_set_gfp_mask(mapping, GFP_NOFS); 431 page = read_mapping_page(mapping, n >> PAGE_SHIFT, NULL); 432 if (!IS_ERR(page)) { 433 kmap(page); 434 if (PageError(page)) 435 goto fail; 436 } 437 return page; 438 439 fail: 440 reiserfs_put_page(page); 441 return ERR_PTR(-EIO); 442 } 443 444 static inline __u32 xattr_hash(const char *msg, int len) 445 { 446 return csum_partial(msg, len, 0); 447 } 448 449 int reiserfs_commit_write(struct file *f, struct page *page, 450 unsigned from, unsigned to); 451 452 static void update_ctime(struct inode *inode) 453 { 454 struct timespec now = current_time(inode); 455 456 if (inode_unhashed(inode) || !inode->i_nlink || 457 timespec_equal(&inode->i_ctime, &now)) 458 return; 459 460 inode->i_ctime = current_time(inode); 461 mark_inode_dirty(inode); 462 } 463 464 static int lookup_and_delete_xattr(struct inode *inode, const char *name) 465 { 466 int err = 0; 467 struct dentry *dentry, *xadir; 468 469 xadir = open_xa_dir(inode, XATTR_REPLACE); 470 if (IS_ERR(xadir)) 471 return PTR_ERR(xadir); 472 473 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR); 474 dentry = lookup_one_len(name, xadir, strlen(name)); 475 if (IS_ERR(dentry)) { 476 err = PTR_ERR(dentry); 477 goto out_dput; 478 } 479 480 if (d_really_is_positive(dentry)) { 481 err = xattr_unlink(d_inode(xadir), dentry); 482 update_ctime(inode); 483 } 484 485 dput(dentry); 486 out_dput: 487 inode_unlock(d_inode(xadir)); 488 dput(xadir); 489 return err; 490 } 491 492 493 /* Generic extended attribute operations that can be used by xa plugins */ 494 495 /* 496 * inode->i_mutex: down 497 */ 498 int 499 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th, 500 struct inode *inode, const char *name, 501 const void *buffer, size_t buffer_size, int flags) 502 { 503 int err = 0; 504 struct dentry *dentry; 505 struct page *page; 506 char *data; 507 size_t file_pos = 0; 508 size_t buffer_pos = 0; 509 size_t new_size; 510 __u32 xahash = 0; 511 512 if (get_inode_sd_version(inode) == STAT_DATA_V1) 513 return -EOPNOTSUPP; 514 515 if (!buffer) { 516 err = lookup_and_delete_xattr(inode, name); 517 return err; 518 } 519 520 dentry = xattr_lookup(inode, name, flags); 521 if (IS_ERR(dentry)) 522 return PTR_ERR(dentry); 523 524 down_write(&REISERFS_I(inode)->i_xattr_sem); 525 526 xahash = xattr_hash(buffer, buffer_size); 527 while (buffer_pos < buffer_size || buffer_pos == 0) { 528 size_t chunk; 529 size_t skip = 0; 530 size_t page_offset = (file_pos & (PAGE_SIZE - 1)); 531 532 if (buffer_size - buffer_pos > PAGE_SIZE) 533 chunk = PAGE_SIZE; 534 else 535 chunk = buffer_size - buffer_pos; 536 537 page = reiserfs_get_page(d_inode(dentry), file_pos); 538 if (IS_ERR(page)) { 539 err = PTR_ERR(page); 540 goto out_unlock; 541 } 542 543 lock_page(page); 544 data = page_address(page); 545 546 if (file_pos == 0) { 547 struct reiserfs_xattr_header *rxh; 548 549 skip = file_pos = sizeof(struct reiserfs_xattr_header); 550 if (chunk + skip > PAGE_SIZE) 551 chunk = PAGE_SIZE - skip; 552 rxh = (struct reiserfs_xattr_header *)data; 553 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC); 554 rxh->h_hash = cpu_to_le32(xahash); 555 } 556 557 reiserfs_write_lock(inode->i_sb); 558 err = __reiserfs_write_begin(page, page_offset, chunk + skip); 559 if (!err) { 560 if (buffer) 561 memcpy(data + skip, buffer + buffer_pos, chunk); 562 err = reiserfs_commit_write(NULL, page, page_offset, 563 page_offset + chunk + 564 skip); 565 } 566 reiserfs_write_unlock(inode->i_sb); 567 unlock_page(page); 568 reiserfs_put_page(page); 569 buffer_pos += chunk; 570 file_pos += chunk; 571 skip = 0; 572 if (err || buffer_size == 0 || !buffer) 573 break; 574 } 575 576 new_size = buffer_size + sizeof(struct reiserfs_xattr_header); 577 if (!err && new_size < i_size_read(d_inode(dentry))) { 578 struct iattr newattrs = { 579 .ia_ctime = current_time(inode), 580 .ia_size = new_size, 581 .ia_valid = ATTR_SIZE | ATTR_CTIME, 582 }; 583 584 inode_lock_nested(d_inode(dentry), I_MUTEX_XATTR); 585 inode_dio_wait(d_inode(dentry)); 586 587 err = reiserfs_setattr(dentry, &newattrs); 588 inode_unlock(d_inode(dentry)); 589 } else 590 update_ctime(inode); 591 out_unlock: 592 up_write(&REISERFS_I(inode)->i_xattr_sem); 593 dput(dentry); 594 return err; 595 } 596 597 /* We need to start a transaction to maintain lock ordering */ 598 int reiserfs_xattr_set(struct inode *inode, const char *name, 599 const void *buffer, size_t buffer_size, int flags) 600 { 601 602 struct reiserfs_transaction_handle th; 603 int error, error2; 604 size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size); 605 606 if (!(flags & XATTR_REPLACE)) 607 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode); 608 609 reiserfs_write_lock(inode->i_sb); 610 error = journal_begin(&th, inode->i_sb, jbegin_count); 611 reiserfs_write_unlock(inode->i_sb); 612 if (error) { 613 return error; 614 } 615 616 error = reiserfs_xattr_set_handle(&th, inode, name, 617 buffer, buffer_size, flags); 618 619 reiserfs_write_lock(inode->i_sb); 620 error2 = journal_end(&th); 621 reiserfs_write_unlock(inode->i_sb); 622 if (error == 0) 623 error = error2; 624 625 return error; 626 } 627 628 /* 629 * inode->i_mutex: down 630 */ 631 int 632 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer, 633 size_t buffer_size) 634 { 635 ssize_t err = 0; 636 struct dentry *dentry; 637 size_t isize; 638 size_t file_pos = 0; 639 size_t buffer_pos = 0; 640 struct page *page; 641 __u32 hash = 0; 642 643 if (name == NULL) 644 return -EINVAL; 645 646 /* 647 * We can't have xattrs attached to v1 items since they don't have 648 * generation numbers 649 */ 650 if (get_inode_sd_version(inode) == STAT_DATA_V1) 651 return -EOPNOTSUPP; 652 653 dentry = xattr_lookup(inode, name, XATTR_REPLACE); 654 if (IS_ERR(dentry)) { 655 err = PTR_ERR(dentry); 656 goto out; 657 } 658 659 down_read(&REISERFS_I(inode)->i_xattr_sem); 660 661 isize = i_size_read(d_inode(dentry)); 662 663 /* Just return the size needed */ 664 if (buffer == NULL) { 665 err = isize - sizeof(struct reiserfs_xattr_header); 666 goto out_unlock; 667 } 668 669 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) { 670 err = -ERANGE; 671 goto out_unlock; 672 } 673 674 while (file_pos < isize) { 675 size_t chunk; 676 char *data; 677 size_t skip = 0; 678 679 if (isize - file_pos > PAGE_SIZE) 680 chunk = PAGE_SIZE; 681 else 682 chunk = isize - file_pos; 683 684 page = reiserfs_get_page(d_inode(dentry), file_pos); 685 if (IS_ERR(page)) { 686 err = PTR_ERR(page); 687 goto out_unlock; 688 } 689 690 lock_page(page); 691 data = page_address(page); 692 if (file_pos == 0) { 693 struct reiserfs_xattr_header *rxh = 694 (struct reiserfs_xattr_header *)data; 695 skip = file_pos = sizeof(struct reiserfs_xattr_header); 696 chunk -= skip; 697 /* Magic doesn't match up.. */ 698 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) { 699 unlock_page(page); 700 reiserfs_put_page(page); 701 reiserfs_warning(inode->i_sb, "jdm-20001", 702 "Invalid magic for xattr (%s) " 703 "associated with %k", name, 704 INODE_PKEY(inode)); 705 err = -EIO; 706 goto out_unlock; 707 } 708 hash = le32_to_cpu(rxh->h_hash); 709 } 710 memcpy(buffer + buffer_pos, data + skip, chunk); 711 unlock_page(page); 712 reiserfs_put_page(page); 713 file_pos += chunk; 714 buffer_pos += chunk; 715 skip = 0; 716 } 717 err = isize - sizeof(struct reiserfs_xattr_header); 718 719 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) != 720 hash) { 721 reiserfs_warning(inode->i_sb, "jdm-20002", 722 "Invalid hash for xattr (%s) associated " 723 "with %k", name, INODE_PKEY(inode)); 724 err = -EIO; 725 } 726 727 out_unlock: 728 up_read(&REISERFS_I(inode)->i_xattr_sem); 729 dput(dentry); 730 731 out: 732 return err; 733 } 734 735 /* 736 * In order to implement different sets of xattr operations for each xattr 737 * prefix with the generic xattr API, a filesystem should create a 738 * null-terminated array of struct xattr_handler (one for each prefix) and 739 * hang a pointer to it off of the s_xattr field of the superblock. 740 * 741 * The generic_fooxattr() functions will use this list to dispatch xattr 742 * operations to the correct xattr_handler. 743 */ 744 #define for_each_xattr_handler(handlers, handler) \ 745 for ((handler) = *(handlers)++; \ 746 (handler) != NULL; \ 747 (handler) = *(handlers)++) 748 749 /* This is the implementation for the xattr plugin infrastructure */ 750 static inline const struct xattr_handler * 751 find_xattr_handler_prefix(const struct xattr_handler **handlers, 752 const char *name) 753 { 754 const struct xattr_handler *xah; 755 756 if (!handlers) 757 return NULL; 758 759 for_each_xattr_handler(handlers, xah) { 760 const char *prefix = xattr_prefix(xah); 761 if (strncmp(prefix, name, strlen(prefix)) == 0) 762 break; 763 } 764 765 return xah; 766 } 767 768 struct listxattr_buf { 769 struct dir_context ctx; 770 size_t size; 771 size_t pos; 772 char *buf; 773 struct dentry *dentry; 774 }; 775 776 static int listxattr_filler(struct dir_context *ctx, const char *name, 777 int namelen, loff_t offset, u64 ino, 778 unsigned int d_type) 779 { 780 struct listxattr_buf *b = 781 container_of(ctx, struct listxattr_buf, ctx); 782 size_t size; 783 784 if (name[0] != '.' || 785 (namelen != 1 && (name[1] != '.' || namelen != 2))) { 786 const struct xattr_handler *handler; 787 788 handler = find_xattr_handler_prefix(b->dentry->d_sb->s_xattr, 789 name); 790 if (!handler /* Unsupported xattr name */ || 791 (handler->list && !handler->list(b->dentry))) 792 return 0; 793 size = namelen + 1; 794 if (b->buf) { 795 if (size > b->size) 796 return -ERANGE; 797 memcpy(b->buf + b->pos, name, namelen); 798 b->buf[b->pos + namelen] = 0; 799 } 800 b->pos += size; 801 } 802 return 0; 803 } 804 805 /* 806 * Inode operation listxattr() 807 * 808 * We totally ignore the generic listxattr here because it would be stupid 809 * not to. Since the xattrs are organized in a directory, we can just 810 * readdir to find them. 811 */ 812 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size) 813 { 814 struct dentry *dir; 815 int err = 0; 816 struct listxattr_buf buf = { 817 .ctx.actor = listxattr_filler, 818 .dentry = dentry, 819 .buf = buffer, 820 .size = buffer ? size : 0, 821 }; 822 823 if (d_really_is_negative(dentry)) 824 return -EINVAL; 825 826 if (!dentry->d_sb->s_xattr || 827 get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 828 return -EOPNOTSUPP; 829 830 dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE); 831 if (IS_ERR(dir)) { 832 err = PTR_ERR(dir); 833 if (err == -ENODATA) 834 err = 0; /* Not an error if there aren't any xattrs */ 835 goto out; 836 } 837 838 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR); 839 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 840 inode_unlock(d_inode(dir)); 841 842 if (!err) 843 err = buf.pos; 844 845 dput(dir); 846 out: 847 return err; 848 } 849 850 static int create_privroot(struct dentry *dentry) 851 { 852 int err; 853 struct inode *inode = d_inode(dentry->d_parent); 854 855 WARN_ON_ONCE(!inode_is_locked(inode)); 856 857 err = xattr_mkdir(inode, dentry, 0700); 858 if (err || d_really_is_negative(dentry)) { 859 reiserfs_warning(dentry->d_sb, "jdm-20006", 860 "xattrs/ACLs enabled and couldn't " 861 "find/create .reiserfs_priv. " 862 "Failing mount."); 863 return -EOPNOTSUPP; 864 } 865 866 d_inode(dentry)->i_flags |= S_PRIVATE; 867 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr " 868 "storage.\n", PRIVROOT_NAME); 869 870 return 0; 871 } 872 873 #else 874 int __init reiserfs_xattr_register_handlers(void) { return 0; } 875 void reiserfs_xattr_unregister_handlers(void) {} 876 static int create_privroot(struct dentry *dentry) { return 0; } 877 #endif 878 879 /* Actual operations that are exported to VFS-land */ 880 static const struct xattr_handler *reiserfs_xattr_handlers[] = { 881 #ifdef CONFIG_REISERFS_FS_XATTR 882 &reiserfs_xattr_user_handler, 883 &reiserfs_xattr_trusted_handler, 884 #endif 885 #ifdef CONFIG_REISERFS_FS_SECURITY 886 &reiserfs_xattr_security_handler, 887 #endif 888 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 889 &posix_acl_access_xattr_handler, 890 &posix_acl_default_xattr_handler, 891 #endif 892 NULL 893 }; 894 895 static int xattr_mount_check(struct super_block *s) 896 { 897 /* 898 * We need generation numbers to ensure that the oid mapping is correct 899 * v3.5 filesystems don't have them. 900 */ 901 if (old_format_only(s)) { 902 if (reiserfs_xattrs_optional(s)) { 903 /* 904 * Old format filesystem, but optional xattrs have 905 * been enabled. Error out. 906 */ 907 reiserfs_warning(s, "jdm-2005", 908 "xattrs/ACLs not supported " 909 "on pre-v3.6 format filesystems. " 910 "Failing mount."); 911 return -EOPNOTSUPP; 912 } 913 } 914 915 return 0; 916 } 917 918 int reiserfs_permission(struct inode *inode, int mask) 919 { 920 /* 921 * We don't do permission checks on the internal objects. 922 * Permissions are determined by the "owning" object. 923 */ 924 if (IS_PRIVATE(inode)) 925 return 0; 926 927 return generic_permission(inode, mask); 928 } 929 930 static int xattr_hide_revalidate(struct dentry *dentry, unsigned int flags) 931 { 932 return -EPERM; 933 } 934 935 static const struct dentry_operations xattr_lookup_poison_ops = { 936 .d_revalidate = xattr_hide_revalidate, 937 }; 938 939 int reiserfs_lookup_privroot(struct super_block *s) 940 { 941 struct dentry *dentry; 942 int err = 0; 943 944 /* If we don't have the privroot located yet - go find it */ 945 inode_lock(d_inode(s->s_root)); 946 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root, 947 strlen(PRIVROOT_NAME)); 948 if (!IS_ERR(dentry)) { 949 REISERFS_SB(s)->priv_root = dentry; 950 d_set_d_op(dentry, &xattr_lookup_poison_ops); 951 if (d_really_is_positive(dentry)) 952 d_inode(dentry)->i_flags |= S_PRIVATE; 953 } else 954 err = PTR_ERR(dentry); 955 inode_unlock(d_inode(s->s_root)); 956 957 return err; 958 } 959 960 /* 961 * We need to take a copy of the mount flags since things like 962 * MS_RDONLY don't get set until *after* we're called. 963 * mount_flags != mount_options 964 */ 965 int reiserfs_xattr_init(struct super_block *s, int mount_flags) 966 { 967 int err = 0; 968 struct dentry *privroot = REISERFS_SB(s)->priv_root; 969 970 err = xattr_mount_check(s); 971 if (err) 972 goto error; 973 974 if (d_really_is_negative(privroot) && !(mount_flags & MS_RDONLY)) { 975 inode_lock(d_inode(s->s_root)); 976 err = create_privroot(REISERFS_SB(s)->priv_root); 977 inode_unlock(d_inode(s->s_root)); 978 } 979 980 if (d_really_is_positive(privroot)) { 981 s->s_xattr = reiserfs_xattr_handlers; 982 inode_lock(d_inode(privroot)); 983 if (!REISERFS_SB(s)->xattr_root) { 984 struct dentry *dentry; 985 986 dentry = lookup_one_len(XAROOT_NAME, privroot, 987 strlen(XAROOT_NAME)); 988 if (!IS_ERR(dentry)) 989 REISERFS_SB(s)->xattr_root = dentry; 990 else 991 err = PTR_ERR(dentry); 992 } 993 inode_unlock(d_inode(privroot)); 994 } 995 996 error: 997 if (err) { 998 clear_bit(REISERFS_XATTRS_USER, &REISERFS_SB(s)->s_mount_opt); 999 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt); 1000 } 1001 1002 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */ 1003 if (reiserfs_posixacl(s)) 1004 s->s_flags |= MS_POSIXACL; 1005 else 1006 s->s_flags &= ~MS_POSIXACL; 1007 1008 return err; 1009 } 1010