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