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