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 int err; 189 struct dentry *dentries[8]; 190 }; 191 192 static int 193 fill_with_dentries(struct dir_context *ctx, const char *name, int namelen, 194 loff_t offset, u64 ino, unsigned int d_type) 195 { 196 struct reiserfs_dentry_buf *dbuf = 197 container_of(ctx, struct reiserfs_dentry_buf, ctx); 198 struct dentry *dentry; 199 200 WARN_ON_ONCE(!inode_is_locked(d_inode(dbuf->xadir))); 201 202 if (dbuf->count == ARRAY_SIZE(dbuf->dentries)) 203 return -ENOSPC; 204 205 if (name[0] == '.' && (namelen < 2 || 206 (namelen == 2 && name[1] == '.'))) 207 return 0; 208 209 dentry = lookup_one_len(name, dbuf->xadir, namelen); 210 if (IS_ERR(dentry)) { 211 dbuf->err = PTR_ERR(dentry); 212 return PTR_ERR(dentry); 213 } else if (d_really_is_negative(dentry)) { 214 /* A directory entry exists, but no file? */ 215 reiserfs_error(dentry->d_sb, "xattr-20003", 216 "Corrupted directory: xattr %pd listed but " 217 "not found for file %pd.\n", 218 dentry, dbuf->xadir); 219 dput(dentry); 220 dbuf->err = -EIO; 221 return -EIO; 222 } 223 224 dbuf->dentries[dbuf->count++] = dentry; 225 return 0; 226 } 227 228 static void 229 cleanup_dentry_buf(struct reiserfs_dentry_buf *buf) 230 { 231 int i; 232 233 for (i = 0; i < buf->count; i++) 234 if (buf->dentries[i]) 235 dput(buf->dentries[i]); 236 } 237 238 static int reiserfs_for_each_xattr(struct inode *inode, 239 int (*action)(struct dentry *, void *), 240 void *data) 241 { 242 struct dentry *dir; 243 int i, err = 0; 244 struct reiserfs_dentry_buf buf = { 245 .ctx.actor = fill_with_dentries, 246 }; 247 248 /* Skip out, an xattr has no xattrs associated with it */ 249 if (IS_PRIVATE(inode) || get_inode_sd_version(inode) == STAT_DATA_V1) 250 return 0; 251 252 dir = open_xa_dir(inode, XATTR_REPLACE); 253 if (IS_ERR(dir)) { 254 err = PTR_ERR(dir); 255 goto out; 256 } else if (d_really_is_negative(dir)) { 257 err = 0; 258 goto out_dir; 259 } 260 261 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR); 262 263 buf.xadir = dir; 264 while (1) { 265 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 266 if (err) 267 break; 268 if (buf.err) { 269 err = buf.err; 270 break; 271 } 272 if (!buf.count) 273 break; 274 for (i = 0; !err && i < buf.count && buf.dentries[i]; i++) { 275 struct dentry *dentry = buf.dentries[i]; 276 277 if (!d_is_dir(dentry)) 278 err = action(dentry, data); 279 280 dput(dentry); 281 buf.dentries[i] = NULL; 282 } 283 if (err) 284 break; 285 buf.count = 0; 286 } 287 inode_unlock(d_inode(dir)); 288 289 cleanup_dentry_buf(&buf); 290 291 if (!err) { 292 /* 293 * We start a transaction here to avoid a ABBA situation 294 * between the xattr root's i_mutex and the journal lock. 295 * This doesn't incur much additional overhead since the 296 * new transaction will just nest inside the 297 * outer transaction. 298 */ 299 int blocks = JOURNAL_PER_BALANCE_CNT * 2 + 2 + 300 4 * REISERFS_QUOTA_TRANS_BLOCKS(inode->i_sb); 301 struct reiserfs_transaction_handle th; 302 303 reiserfs_write_lock(inode->i_sb); 304 err = journal_begin(&th, inode->i_sb, blocks); 305 reiserfs_write_unlock(inode->i_sb); 306 if (!err) { 307 int jerror; 308 309 inode_lock_nested(d_inode(dir->d_parent), 310 I_MUTEX_XATTR); 311 err = action(dir, data); 312 reiserfs_write_lock(inode->i_sb); 313 jerror = journal_end(&th); 314 reiserfs_write_unlock(inode->i_sb); 315 inode_unlock(d_inode(dir->d_parent)); 316 err = jerror ?: err; 317 } 318 } 319 out_dir: 320 dput(dir); 321 out: 322 /* -ENODATA isn't an error */ 323 if (err == -ENODATA) 324 err = 0; 325 return err; 326 } 327 328 static int delete_one_xattr(struct dentry *dentry, void *data) 329 { 330 struct inode *dir = d_inode(dentry->d_parent); 331 332 /* This is the xattr dir, handle specially. */ 333 if (d_is_dir(dentry)) 334 return xattr_rmdir(dir, dentry); 335 336 return xattr_unlink(dir, dentry); 337 } 338 339 static int chown_one_xattr(struct dentry *dentry, void *data) 340 { 341 struct iattr *attrs = data; 342 int ia_valid = attrs->ia_valid; 343 int err; 344 345 /* 346 * We only want the ownership bits. Otherwise, we'll do 347 * things like change a directory to a regular file if 348 * ATTR_MODE is set. 349 */ 350 attrs->ia_valid &= (ATTR_UID|ATTR_GID); 351 err = reiserfs_setattr(dentry, attrs); 352 attrs->ia_valid = ia_valid; 353 354 return err; 355 } 356 357 /* No i_mutex, but the inode is unconnected. */ 358 int reiserfs_delete_xattrs(struct inode *inode) 359 { 360 int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL); 361 362 if (err) 363 reiserfs_warning(inode->i_sb, "jdm-20004", 364 "Couldn't delete all xattrs (%d)\n", err); 365 return err; 366 } 367 368 /* inode->i_mutex: down */ 369 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs) 370 { 371 int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs); 372 373 if (err) 374 reiserfs_warning(inode->i_sb, "jdm-20007", 375 "Couldn't chown all xattrs (%d)\n", err); 376 return err; 377 } 378 379 #ifdef CONFIG_REISERFS_FS_XATTR 380 /* 381 * Returns a dentry corresponding to a specific extended attribute file 382 * for the inode. If flags allow, the file is created. Otherwise, a 383 * valid or negative dentry, or an error is returned. 384 */ 385 static struct dentry *xattr_lookup(struct inode *inode, const char *name, 386 int flags) 387 { 388 struct dentry *xadir, *xafile; 389 int err = 0; 390 391 xadir = open_xa_dir(inode, flags); 392 if (IS_ERR(xadir)) 393 return ERR_CAST(xadir); 394 395 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR); 396 xafile = lookup_one_len(name, xadir, strlen(name)); 397 if (IS_ERR(xafile)) { 398 err = PTR_ERR(xafile); 399 goto out; 400 } 401 402 if (d_really_is_positive(xafile) && (flags & XATTR_CREATE)) 403 err = -EEXIST; 404 405 if (d_really_is_negative(xafile)) { 406 err = -ENODATA; 407 if (xattr_may_create(flags)) 408 err = xattr_create(d_inode(xadir), xafile, 409 0700|S_IFREG); 410 } 411 412 if (err) 413 dput(xafile); 414 out: 415 inode_unlock(d_inode(xadir)); 416 dput(xadir); 417 if (err) 418 return ERR_PTR(err); 419 return xafile; 420 } 421 422 /* Internal operations on file data */ 423 static inline void reiserfs_put_page(struct page *page) 424 { 425 kunmap(page); 426 put_page(page); 427 } 428 429 static struct page *reiserfs_get_page(struct inode *dir, size_t n) 430 { 431 struct address_space *mapping = dir->i_mapping; 432 struct page *page; 433 /* 434 * We can deadlock if we try to free dentries, 435 * and an unlink/rmdir has just occurred - GFP_NOFS avoids this 436 */ 437 mapping_set_gfp_mask(mapping, GFP_NOFS); 438 page = read_mapping_page(mapping, n >> PAGE_SHIFT, NULL); 439 if (!IS_ERR(page)) { 440 kmap(page); 441 if (PageError(page)) 442 goto fail; 443 } 444 return page; 445 446 fail: 447 reiserfs_put_page(page); 448 return ERR_PTR(-EIO); 449 } 450 451 static inline __u32 xattr_hash(const char *msg, int len) 452 { 453 /* 454 * csum_partial() gives different results for little-endian and 455 * big endian hosts. Images created on little-endian hosts and 456 * mounted on big-endian hosts(and vice versa) will see csum mismatches 457 * when trying to fetch xattrs. Treating the hash as __wsum_t would 458 * lower the frequency of mismatch. This is an endianness bug in 459 * reiserfs. The return statement would result in a sparse warning. Do 460 * not fix the sparse warning so as to not hide a reminder of the bug. 461 */ 462 return csum_partial(msg, len, 0); 463 } 464 465 int reiserfs_commit_write(struct file *f, struct page *page, 466 unsigned from, unsigned to); 467 468 static void update_ctime(struct inode *inode) 469 { 470 struct timespec64 now = current_time(inode); 471 472 if (inode_unhashed(inode) || !inode->i_nlink || 473 timespec64_equal(&inode->i_ctime, &now)) 474 return; 475 476 inode->i_ctime = current_time(inode); 477 mark_inode_dirty(inode); 478 } 479 480 static int lookup_and_delete_xattr(struct inode *inode, const char *name) 481 { 482 int err = 0; 483 struct dentry *dentry, *xadir; 484 485 xadir = open_xa_dir(inode, XATTR_REPLACE); 486 if (IS_ERR(xadir)) 487 return PTR_ERR(xadir); 488 489 inode_lock_nested(d_inode(xadir), I_MUTEX_XATTR); 490 dentry = lookup_one_len(name, xadir, strlen(name)); 491 if (IS_ERR(dentry)) { 492 err = PTR_ERR(dentry); 493 goto out_dput; 494 } 495 496 if (d_really_is_positive(dentry)) { 497 err = xattr_unlink(d_inode(xadir), dentry); 498 update_ctime(inode); 499 } 500 501 dput(dentry); 502 out_dput: 503 inode_unlock(d_inode(xadir)); 504 dput(xadir); 505 return err; 506 } 507 508 509 /* Generic extended attribute operations that can be used by xa plugins */ 510 511 /* 512 * inode->i_mutex: down 513 */ 514 int 515 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th, 516 struct inode *inode, const char *name, 517 const void *buffer, size_t buffer_size, int flags) 518 { 519 int err = 0; 520 struct dentry *dentry; 521 struct page *page; 522 char *data; 523 size_t file_pos = 0; 524 size_t buffer_pos = 0; 525 size_t new_size; 526 __u32 xahash = 0; 527 528 if (get_inode_sd_version(inode) == STAT_DATA_V1) 529 return -EOPNOTSUPP; 530 531 if (!buffer) { 532 err = lookup_and_delete_xattr(inode, name); 533 return err; 534 } 535 536 dentry = xattr_lookup(inode, name, flags); 537 if (IS_ERR(dentry)) 538 return PTR_ERR(dentry); 539 540 down_write(&REISERFS_I(inode)->i_xattr_sem); 541 542 xahash = xattr_hash(buffer, buffer_size); 543 while (buffer_pos < buffer_size || buffer_pos == 0) { 544 size_t chunk; 545 size_t skip = 0; 546 size_t page_offset = (file_pos & (PAGE_SIZE - 1)); 547 548 if (buffer_size - buffer_pos > PAGE_SIZE) 549 chunk = PAGE_SIZE; 550 else 551 chunk = buffer_size - buffer_pos; 552 553 page = reiserfs_get_page(d_inode(dentry), file_pos); 554 if (IS_ERR(page)) { 555 err = PTR_ERR(page); 556 goto out_unlock; 557 } 558 559 lock_page(page); 560 data = page_address(page); 561 562 if (file_pos == 0) { 563 struct reiserfs_xattr_header *rxh; 564 565 skip = file_pos = sizeof(struct reiserfs_xattr_header); 566 if (chunk + skip > PAGE_SIZE) 567 chunk = PAGE_SIZE - skip; 568 rxh = (struct reiserfs_xattr_header *)data; 569 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC); 570 rxh->h_hash = cpu_to_le32(xahash); 571 } 572 573 reiserfs_write_lock(inode->i_sb); 574 err = __reiserfs_write_begin(page, page_offset, chunk + skip); 575 if (!err) { 576 if (buffer) 577 memcpy(data + skip, buffer + buffer_pos, chunk); 578 err = reiserfs_commit_write(NULL, page, page_offset, 579 page_offset + chunk + 580 skip); 581 } 582 reiserfs_write_unlock(inode->i_sb); 583 unlock_page(page); 584 reiserfs_put_page(page); 585 buffer_pos += chunk; 586 file_pos += chunk; 587 skip = 0; 588 if (err || buffer_size == 0 || !buffer) 589 break; 590 } 591 592 new_size = buffer_size + sizeof(struct reiserfs_xattr_header); 593 if (!err && new_size < i_size_read(d_inode(dentry))) { 594 struct iattr newattrs = { 595 .ia_ctime = current_time(inode), 596 .ia_size = new_size, 597 .ia_valid = ATTR_SIZE | ATTR_CTIME, 598 }; 599 600 inode_lock_nested(d_inode(dentry), I_MUTEX_XATTR); 601 inode_dio_wait(d_inode(dentry)); 602 603 err = reiserfs_setattr(dentry, &newattrs); 604 inode_unlock(d_inode(dentry)); 605 } else 606 update_ctime(inode); 607 out_unlock: 608 up_write(&REISERFS_I(inode)->i_xattr_sem); 609 dput(dentry); 610 return err; 611 } 612 613 /* We need to start a transaction to maintain lock ordering */ 614 int reiserfs_xattr_set(struct inode *inode, const char *name, 615 const void *buffer, size_t buffer_size, int flags) 616 { 617 618 struct reiserfs_transaction_handle th; 619 int error, error2; 620 size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size); 621 622 if (!(flags & XATTR_REPLACE)) 623 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode); 624 625 reiserfs_write_lock(inode->i_sb); 626 error = journal_begin(&th, inode->i_sb, jbegin_count); 627 reiserfs_write_unlock(inode->i_sb); 628 if (error) { 629 return error; 630 } 631 632 error = reiserfs_xattr_set_handle(&th, inode, name, 633 buffer, buffer_size, flags); 634 635 reiserfs_write_lock(inode->i_sb); 636 error2 = journal_end(&th); 637 reiserfs_write_unlock(inode->i_sb); 638 if (error == 0) 639 error = error2; 640 641 return error; 642 } 643 644 /* 645 * inode->i_mutex: down 646 */ 647 int 648 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer, 649 size_t buffer_size) 650 { 651 ssize_t err = 0; 652 struct dentry *dentry; 653 size_t isize; 654 size_t file_pos = 0; 655 size_t buffer_pos = 0; 656 struct page *page; 657 __u32 hash = 0; 658 659 if (name == NULL) 660 return -EINVAL; 661 662 /* 663 * We can't have xattrs attached to v1 items since they don't have 664 * generation numbers 665 */ 666 if (get_inode_sd_version(inode) == STAT_DATA_V1) 667 return -EOPNOTSUPP; 668 669 dentry = xattr_lookup(inode, name, XATTR_REPLACE); 670 if (IS_ERR(dentry)) { 671 err = PTR_ERR(dentry); 672 goto out; 673 } 674 675 down_read(&REISERFS_I(inode)->i_xattr_sem); 676 677 isize = i_size_read(d_inode(dentry)); 678 679 /* Just return the size needed */ 680 if (buffer == NULL) { 681 err = isize - sizeof(struct reiserfs_xattr_header); 682 goto out_unlock; 683 } 684 685 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) { 686 err = -ERANGE; 687 goto out_unlock; 688 } 689 690 while (file_pos < isize) { 691 size_t chunk; 692 char *data; 693 size_t skip = 0; 694 695 if (isize - file_pos > PAGE_SIZE) 696 chunk = PAGE_SIZE; 697 else 698 chunk = isize - file_pos; 699 700 page = reiserfs_get_page(d_inode(dentry), file_pos); 701 if (IS_ERR(page)) { 702 err = PTR_ERR(page); 703 goto out_unlock; 704 } 705 706 lock_page(page); 707 data = page_address(page); 708 if (file_pos == 0) { 709 struct reiserfs_xattr_header *rxh = 710 (struct reiserfs_xattr_header *)data; 711 skip = file_pos = sizeof(struct reiserfs_xattr_header); 712 chunk -= skip; 713 /* Magic doesn't match up.. */ 714 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) { 715 unlock_page(page); 716 reiserfs_put_page(page); 717 reiserfs_warning(inode->i_sb, "jdm-20001", 718 "Invalid magic for xattr (%s) " 719 "associated with %k", name, 720 INODE_PKEY(inode)); 721 err = -EIO; 722 goto out_unlock; 723 } 724 hash = le32_to_cpu(rxh->h_hash); 725 } 726 memcpy(buffer + buffer_pos, data + skip, chunk); 727 unlock_page(page); 728 reiserfs_put_page(page); 729 file_pos += chunk; 730 buffer_pos += chunk; 731 skip = 0; 732 } 733 err = isize - sizeof(struct reiserfs_xattr_header); 734 735 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) != 736 hash) { 737 reiserfs_warning(inode->i_sb, "jdm-20002", 738 "Invalid hash for xattr (%s) associated " 739 "with %k", name, INODE_PKEY(inode)); 740 err = -EIO; 741 } 742 743 out_unlock: 744 up_read(&REISERFS_I(inode)->i_xattr_sem); 745 dput(dentry); 746 747 out: 748 return err; 749 } 750 751 /* 752 * In order to implement different sets of xattr operations for each xattr 753 * prefix with the generic xattr API, a filesystem should create a 754 * null-terminated array of struct xattr_handler (one for each prefix) and 755 * hang a pointer to it off of the s_xattr field of the superblock. 756 * 757 * The generic_fooxattr() functions will use this list to dispatch xattr 758 * operations to the correct xattr_handler. 759 */ 760 #define for_each_xattr_handler(handlers, handler) \ 761 for ((handler) = *(handlers)++; \ 762 (handler) != NULL; \ 763 (handler) = *(handlers)++) 764 765 /* This is the implementation for the xattr plugin infrastructure */ 766 static inline const struct xattr_handler * 767 find_xattr_handler_prefix(const struct xattr_handler **handlers, 768 const char *name) 769 { 770 const struct xattr_handler *xah; 771 772 if (!handlers) 773 return NULL; 774 775 for_each_xattr_handler(handlers, xah) { 776 const char *prefix = xattr_prefix(xah); 777 if (strncmp(prefix, name, strlen(prefix)) == 0) 778 break; 779 } 780 781 return xah; 782 } 783 784 struct listxattr_buf { 785 struct dir_context ctx; 786 size_t size; 787 size_t pos; 788 char *buf; 789 struct dentry *dentry; 790 }; 791 792 static int listxattr_filler(struct dir_context *ctx, const char *name, 793 int namelen, loff_t offset, u64 ino, 794 unsigned int d_type) 795 { 796 struct listxattr_buf *b = 797 container_of(ctx, struct listxattr_buf, ctx); 798 size_t size; 799 800 if (name[0] != '.' || 801 (namelen != 1 && (name[1] != '.' || namelen != 2))) { 802 const struct xattr_handler *handler; 803 804 handler = find_xattr_handler_prefix(b->dentry->d_sb->s_xattr, 805 name); 806 if (!handler /* Unsupported xattr name */ || 807 (handler->list && !handler->list(b->dentry))) 808 return 0; 809 size = namelen + 1; 810 if (b->buf) { 811 if (b->pos + size > b->size) { 812 b->pos = -ERANGE; 813 return -ERANGE; 814 } 815 memcpy(b->buf + b->pos, name, namelen); 816 b->buf[b->pos + namelen] = 0; 817 } 818 b->pos += size; 819 } 820 return 0; 821 } 822 823 /* 824 * Inode operation listxattr() 825 * 826 * We totally ignore the generic listxattr here because it would be stupid 827 * not to. Since the xattrs are organized in a directory, we can just 828 * readdir to find them. 829 */ 830 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size) 831 { 832 struct dentry *dir; 833 int err = 0; 834 struct listxattr_buf buf = { 835 .ctx.actor = listxattr_filler, 836 .dentry = dentry, 837 .buf = buffer, 838 .size = buffer ? size : 0, 839 }; 840 841 if (d_really_is_negative(dentry)) 842 return -EINVAL; 843 844 if (!dentry->d_sb->s_xattr || 845 get_inode_sd_version(d_inode(dentry)) == STAT_DATA_V1) 846 return -EOPNOTSUPP; 847 848 dir = open_xa_dir(d_inode(dentry), XATTR_REPLACE); 849 if (IS_ERR(dir)) { 850 err = PTR_ERR(dir); 851 if (err == -ENODATA) 852 err = 0; /* Not an error if there aren't any xattrs */ 853 goto out; 854 } 855 856 inode_lock_nested(d_inode(dir), I_MUTEX_XATTR); 857 err = reiserfs_readdir_inode(d_inode(dir), &buf.ctx); 858 inode_unlock(d_inode(dir)); 859 860 if (!err) 861 err = buf.pos; 862 863 dput(dir); 864 out: 865 return err; 866 } 867 868 static int create_privroot(struct dentry *dentry) 869 { 870 int err; 871 struct inode *inode = d_inode(dentry->d_parent); 872 873 WARN_ON_ONCE(!inode_is_locked(inode)); 874 875 err = xattr_mkdir(inode, dentry, 0700); 876 if (err || d_really_is_negative(dentry)) { 877 reiserfs_warning(dentry->d_sb, "jdm-20006", 878 "xattrs/ACLs enabled and couldn't " 879 "find/create .reiserfs_priv. " 880 "Failing mount."); 881 return -EOPNOTSUPP; 882 } 883 884 d_inode(dentry)->i_flags |= S_PRIVATE; 885 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr " 886 "storage.\n", PRIVROOT_NAME); 887 888 return 0; 889 } 890 891 #else 892 int __init reiserfs_xattr_register_handlers(void) { return 0; } 893 void reiserfs_xattr_unregister_handlers(void) {} 894 static int create_privroot(struct dentry *dentry) { return 0; } 895 #endif 896 897 /* Actual operations that are exported to VFS-land */ 898 static const struct xattr_handler *reiserfs_xattr_handlers[] = { 899 #ifdef CONFIG_REISERFS_FS_XATTR 900 &reiserfs_xattr_user_handler, 901 &reiserfs_xattr_trusted_handler, 902 #endif 903 #ifdef CONFIG_REISERFS_FS_SECURITY 904 &reiserfs_xattr_security_handler, 905 #endif 906 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 907 &posix_acl_access_xattr_handler, 908 &posix_acl_default_xattr_handler, 909 #endif 910 NULL 911 }; 912 913 static int xattr_mount_check(struct super_block *s) 914 { 915 /* 916 * We need generation numbers to ensure that the oid mapping is correct 917 * v3.5 filesystems don't have them. 918 */ 919 if (old_format_only(s)) { 920 if (reiserfs_xattrs_optional(s)) { 921 /* 922 * Old format filesystem, but optional xattrs have 923 * been enabled. Error out. 924 */ 925 reiserfs_warning(s, "jdm-2005", 926 "xattrs/ACLs not supported " 927 "on pre-v3.6 format filesystems. " 928 "Failing mount."); 929 return -EOPNOTSUPP; 930 } 931 } 932 933 return 0; 934 } 935 936 int reiserfs_permission(struct inode *inode, int mask) 937 { 938 /* 939 * We don't do permission checks on the internal objects. 940 * Permissions are determined by the "owning" object. 941 */ 942 if (IS_PRIVATE(inode)) 943 return 0; 944 945 return generic_permission(inode, mask); 946 } 947 948 static int xattr_hide_revalidate(struct dentry *dentry, unsigned int flags) 949 { 950 return -EPERM; 951 } 952 953 static const struct dentry_operations xattr_lookup_poison_ops = { 954 .d_revalidate = xattr_hide_revalidate, 955 }; 956 957 int reiserfs_lookup_privroot(struct super_block *s) 958 { 959 struct dentry *dentry; 960 int err = 0; 961 962 /* If we don't have the privroot located yet - go find it */ 963 inode_lock(d_inode(s->s_root)); 964 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root, 965 strlen(PRIVROOT_NAME)); 966 if (!IS_ERR(dentry)) { 967 REISERFS_SB(s)->priv_root = dentry; 968 d_set_d_op(dentry, &xattr_lookup_poison_ops); 969 if (d_really_is_positive(dentry)) 970 d_inode(dentry)->i_flags |= S_PRIVATE; 971 } else 972 err = PTR_ERR(dentry); 973 inode_unlock(d_inode(s->s_root)); 974 975 return err; 976 } 977 978 /* 979 * We need to take a copy of the mount flags since things like 980 * SB_RDONLY don't get set until *after* we're called. 981 * mount_flags != mount_options 982 */ 983 int reiserfs_xattr_init(struct super_block *s, int mount_flags) 984 { 985 int err = 0; 986 struct dentry *privroot = REISERFS_SB(s)->priv_root; 987 988 err = xattr_mount_check(s); 989 if (err) 990 goto error; 991 992 if (d_really_is_negative(privroot) && !(mount_flags & SB_RDONLY)) { 993 inode_lock(d_inode(s->s_root)); 994 err = create_privroot(REISERFS_SB(s)->priv_root); 995 inode_unlock(d_inode(s->s_root)); 996 } 997 998 if (d_really_is_positive(privroot)) { 999 s->s_xattr = reiserfs_xattr_handlers; 1000 inode_lock(d_inode(privroot)); 1001 if (!REISERFS_SB(s)->xattr_root) { 1002 struct dentry *dentry; 1003 1004 dentry = lookup_one_len(XAROOT_NAME, privroot, 1005 strlen(XAROOT_NAME)); 1006 if (!IS_ERR(dentry)) 1007 REISERFS_SB(s)->xattr_root = dentry; 1008 else 1009 err = PTR_ERR(dentry); 1010 } 1011 inode_unlock(d_inode(privroot)); 1012 } 1013 1014 error: 1015 if (err) { 1016 clear_bit(REISERFS_XATTRS_USER, &REISERFS_SB(s)->s_mount_opt); 1017 clear_bit(REISERFS_POSIXACL, &REISERFS_SB(s)->s_mount_opt); 1018 } 1019 1020 /* The super_block SB_POSIXACL must mirror the (no)acl mount option. */ 1021 if (reiserfs_posixacl(s)) 1022 s->s_flags |= SB_POSIXACL; 1023 else 1024 s->s_flags &= ~SB_POSIXACL; 1025 1026 return err; 1027 } 1028