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 reiserfs_mutex_lock_nested_safe( 293 &dir->d_parent->d_inode->i_mutex, 294 I_MUTEX_XATTR, inode->i_sb); 295 err = action(dir, data); 296 jerror = journal_end(&th, inode->i_sb, blocks); 297 mutex_unlock(&dir->d_parent->d_inode->i_mutex); 298 err = jerror ?: err; 299 } 300 } 301 out_dir: 302 dput(dir); 303 out: 304 /* -ENODATA isn't an error */ 305 if (err == -ENODATA) 306 err = 0; 307 return err; 308 } 309 310 static int delete_one_xattr(struct dentry *dentry, void *data) 311 { 312 struct inode *dir = dentry->d_parent->d_inode; 313 314 /* This is the xattr dir, handle specially. */ 315 if (S_ISDIR(dentry->d_inode->i_mode)) 316 return xattr_rmdir(dir, dentry); 317 318 return xattr_unlink(dir, dentry); 319 } 320 321 static int chown_one_xattr(struct dentry *dentry, void *data) 322 { 323 struct iattr *attrs = data; 324 return reiserfs_setattr(dentry, attrs); 325 } 326 327 /* No i_mutex, but the inode is unconnected. */ 328 int reiserfs_delete_xattrs(struct inode *inode) 329 { 330 int err = reiserfs_for_each_xattr(inode, delete_one_xattr, NULL); 331 if (err) 332 reiserfs_warning(inode->i_sb, "jdm-20004", 333 "Couldn't delete all xattrs (%d)\n", err); 334 return err; 335 } 336 337 /* inode->i_mutex: down */ 338 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs) 339 { 340 int err = reiserfs_for_each_xattr(inode, chown_one_xattr, attrs); 341 if (err) 342 reiserfs_warning(inode->i_sb, "jdm-20007", 343 "Couldn't chown all xattrs (%d)\n", err); 344 return err; 345 } 346 347 #ifdef CONFIG_REISERFS_FS_XATTR 348 /* Returns a dentry corresponding to a specific extended attribute file 349 * for the inode. If flags allow, the file is created. Otherwise, a 350 * valid or negative dentry, or an error is returned. */ 351 static struct dentry *xattr_lookup(struct inode *inode, const char *name, 352 int flags) 353 { 354 struct dentry *xadir, *xafile; 355 int err = 0; 356 357 xadir = open_xa_dir(inode, flags); 358 if (IS_ERR(xadir)) 359 return ERR_CAST(xadir); 360 361 mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR); 362 xafile = lookup_one_len(name, xadir, strlen(name)); 363 if (IS_ERR(xafile)) { 364 err = PTR_ERR(xafile); 365 goto out; 366 } 367 368 if (xafile->d_inode && (flags & XATTR_CREATE)) 369 err = -EEXIST; 370 371 if (!xafile->d_inode) { 372 err = -ENODATA; 373 if (xattr_may_create(flags)) 374 err = xattr_create(xadir->d_inode, xafile, 375 0700|S_IFREG); 376 } 377 378 if (err) 379 dput(xafile); 380 out: 381 mutex_unlock(&xadir->d_inode->i_mutex); 382 dput(xadir); 383 if (err) 384 return ERR_PTR(err); 385 return xafile; 386 } 387 388 /* Internal operations on file data */ 389 static inline void reiserfs_put_page(struct page *page) 390 { 391 kunmap(page); 392 page_cache_release(page); 393 } 394 395 static struct page *reiserfs_get_page(struct inode *dir, size_t n) 396 { 397 struct address_space *mapping = dir->i_mapping; 398 struct page *page; 399 /* We can deadlock if we try to free dentries, 400 and an unlink/rmdir has just occured - GFP_NOFS avoids this */ 401 mapping_set_gfp_mask(mapping, GFP_NOFS); 402 page = read_mapping_page(mapping, n >> PAGE_CACHE_SHIFT, NULL); 403 if (!IS_ERR(page)) { 404 kmap(page); 405 if (PageError(page)) 406 goto fail; 407 } 408 return page; 409 410 fail: 411 reiserfs_put_page(page); 412 return ERR_PTR(-EIO); 413 } 414 415 static inline __u32 xattr_hash(const char *msg, int len) 416 { 417 return csum_partial(msg, len, 0); 418 } 419 420 int reiserfs_commit_write(struct file *f, struct page *page, 421 unsigned from, unsigned to); 422 int reiserfs_prepare_write(struct file *f, struct page *page, 423 unsigned from, unsigned to); 424 425 static void update_ctime(struct inode *inode) 426 { 427 struct timespec now = current_fs_time(inode->i_sb); 428 if (hlist_unhashed(&inode->i_hash) || !inode->i_nlink || 429 timespec_equal(&inode->i_ctime, &now)) 430 return; 431 432 inode->i_ctime = CURRENT_TIME_SEC; 433 mark_inode_dirty(inode); 434 } 435 436 static int lookup_and_delete_xattr(struct inode *inode, const char *name) 437 { 438 int err = 0; 439 struct dentry *dentry, *xadir; 440 441 xadir = open_xa_dir(inode, XATTR_REPLACE); 442 if (IS_ERR(xadir)) 443 return PTR_ERR(xadir); 444 445 mutex_lock_nested(&xadir->d_inode->i_mutex, I_MUTEX_XATTR); 446 dentry = lookup_one_len(name, xadir, strlen(name)); 447 if (IS_ERR(dentry)) { 448 err = PTR_ERR(dentry); 449 goto out_dput; 450 } 451 452 if (dentry->d_inode) { 453 err = xattr_unlink(xadir->d_inode, dentry); 454 update_ctime(inode); 455 } 456 457 dput(dentry); 458 out_dput: 459 mutex_unlock(&xadir->d_inode->i_mutex); 460 dput(xadir); 461 return err; 462 } 463 464 465 /* Generic extended attribute operations that can be used by xa plugins */ 466 467 /* 468 * inode->i_mutex: down 469 */ 470 int 471 reiserfs_xattr_set_handle(struct reiserfs_transaction_handle *th, 472 struct inode *inode, const char *name, 473 const void *buffer, size_t buffer_size, int flags) 474 { 475 int err = 0; 476 struct dentry *dentry; 477 struct page *page; 478 char *data; 479 size_t file_pos = 0; 480 size_t buffer_pos = 0; 481 size_t new_size; 482 __u32 xahash = 0; 483 484 if (get_inode_sd_version(inode) == STAT_DATA_V1) 485 return -EOPNOTSUPP; 486 487 if (!buffer) 488 return lookup_and_delete_xattr(inode, name); 489 490 reiserfs_write_unlock(inode->i_sb); 491 dentry = xattr_lookup(inode, name, flags); 492 if (IS_ERR(dentry)) { 493 reiserfs_write_lock(inode->i_sb); 494 return PTR_ERR(dentry); 495 } 496 497 down_read(&REISERFS_I(inode)->i_xattr_sem); 498 499 reiserfs_write_lock(inode->i_sb); 500 501 xahash = xattr_hash(buffer, buffer_size); 502 while (buffer_pos < buffer_size || buffer_pos == 0) { 503 size_t chunk; 504 size_t skip = 0; 505 size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1)); 506 if (buffer_size - buffer_pos > PAGE_CACHE_SIZE) 507 chunk = PAGE_CACHE_SIZE; 508 else 509 chunk = buffer_size - buffer_pos; 510 511 page = reiserfs_get_page(dentry->d_inode, file_pos); 512 if (IS_ERR(page)) { 513 err = PTR_ERR(page); 514 goto out_unlock; 515 } 516 517 lock_page(page); 518 data = page_address(page); 519 520 if (file_pos == 0) { 521 struct reiserfs_xattr_header *rxh; 522 skip = file_pos = sizeof(struct reiserfs_xattr_header); 523 if (chunk + skip > PAGE_CACHE_SIZE) 524 chunk = PAGE_CACHE_SIZE - skip; 525 rxh = (struct reiserfs_xattr_header *)data; 526 rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC); 527 rxh->h_hash = cpu_to_le32(xahash); 528 } 529 530 err = reiserfs_prepare_write(NULL, page, page_offset, 531 page_offset + chunk + skip); 532 if (!err) { 533 if (buffer) 534 memcpy(data + skip, buffer + buffer_pos, chunk); 535 err = reiserfs_commit_write(NULL, page, page_offset, 536 page_offset + chunk + 537 skip); 538 } 539 unlock_page(page); 540 reiserfs_put_page(page); 541 buffer_pos += chunk; 542 file_pos += chunk; 543 skip = 0; 544 if (err || buffer_size == 0 || !buffer) 545 break; 546 } 547 548 new_size = buffer_size + sizeof(struct reiserfs_xattr_header); 549 if (!err && new_size < i_size_read(dentry->d_inode)) { 550 struct iattr newattrs = { 551 .ia_ctime = current_fs_time(inode->i_sb), 552 .ia_size = buffer_size, 553 .ia_valid = ATTR_SIZE | ATTR_CTIME, 554 }; 555 mutex_lock_nested(&dentry->d_inode->i_mutex, I_MUTEX_XATTR); 556 down_write(&dentry->d_inode->i_alloc_sem); 557 err = reiserfs_setattr(dentry, &newattrs); 558 up_write(&dentry->d_inode->i_alloc_sem); 559 mutex_unlock(&dentry->d_inode->i_mutex); 560 } else 561 update_ctime(inode); 562 out_unlock: 563 up_write(&REISERFS_I(inode)->i_xattr_sem); 564 dput(dentry); 565 return err; 566 } 567 568 /* We need to start a transaction to maintain lock ordering */ 569 int reiserfs_xattr_set(struct inode *inode, const char *name, 570 const void *buffer, size_t buffer_size, int flags) 571 { 572 573 struct reiserfs_transaction_handle th; 574 int error, error2; 575 size_t jbegin_count = reiserfs_xattr_nblocks(inode, buffer_size); 576 577 if (!(flags & XATTR_REPLACE)) 578 jbegin_count += reiserfs_xattr_jcreate_nblocks(inode); 579 580 reiserfs_write_lock(inode->i_sb); 581 error = journal_begin(&th, inode->i_sb, jbegin_count); 582 if (error) { 583 reiserfs_write_unlock(inode->i_sb); 584 return error; 585 } 586 587 error = reiserfs_xattr_set_handle(&th, inode, name, 588 buffer, buffer_size, flags); 589 590 error2 = journal_end(&th, inode->i_sb, jbegin_count); 591 if (error == 0) 592 error = error2; 593 reiserfs_write_unlock(inode->i_sb); 594 595 return error; 596 } 597 598 /* 599 * inode->i_mutex: down 600 */ 601 int 602 reiserfs_xattr_get(struct inode *inode, const char *name, void *buffer, 603 size_t buffer_size) 604 { 605 ssize_t err = 0; 606 struct dentry *dentry; 607 size_t isize; 608 size_t file_pos = 0; 609 size_t buffer_pos = 0; 610 struct page *page; 611 __u32 hash = 0; 612 613 if (name == NULL) 614 return -EINVAL; 615 616 /* We can't have xattrs attached to v1 items since they don't have 617 * generation numbers */ 618 if (get_inode_sd_version(inode) == STAT_DATA_V1) 619 return -EOPNOTSUPP; 620 621 dentry = xattr_lookup(inode, name, XATTR_REPLACE); 622 if (IS_ERR(dentry)) { 623 err = PTR_ERR(dentry); 624 goto out; 625 } 626 627 down_read(&REISERFS_I(inode)->i_xattr_sem); 628 629 isize = i_size_read(dentry->d_inode); 630 631 /* Just return the size needed */ 632 if (buffer == NULL) { 633 err = isize - sizeof(struct reiserfs_xattr_header); 634 goto out_unlock; 635 } 636 637 if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) { 638 err = -ERANGE; 639 goto out_unlock; 640 } 641 642 while (file_pos < isize) { 643 size_t chunk; 644 char *data; 645 size_t skip = 0; 646 if (isize - file_pos > PAGE_CACHE_SIZE) 647 chunk = PAGE_CACHE_SIZE; 648 else 649 chunk = isize - file_pos; 650 651 page = reiserfs_get_page(dentry->d_inode, file_pos); 652 if (IS_ERR(page)) { 653 err = PTR_ERR(page); 654 goto out_unlock; 655 } 656 657 lock_page(page); 658 data = page_address(page); 659 if (file_pos == 0) { 660 struct reiserfs_xattr_header *rxh = 661 (struct reiserfs_xattr_header *)data; 662 skip = file_pos = sizeof(struct reiserfs_xattr_header); 663 chunk -= skip; 664 /* Magic doesn't match up.. */ 665 if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) { 666 unlock_page(page); 667 reiserfs_put_page(page); 668 reiserfs_warning(inode->i_sb, "jdm-20001", 669 "Invalid magic for xattr (%s) " 670 "associated with %k", name, 671 INODE_PKEY(inode)); 672 err = -EIO; 673 goto out_unlock; 674 } 675 hash = le32_to_cpu(rxh->h_hash); 676 } 677 memcpy(buffer + buffer_pos, data + skip, chunk); 678 unlock_page(page); 679 reiserfs_put_page(page); 680 file_pos += chunk; 681 buffer_pos += chunk; 682 skip = 0; 683 } 684 err = isize - sizeof(struct reiserfs_xattr_header); 685 686 if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) != 687 hash) { 688 reiserfs_warning(inode->i_sb, "jdm-20002", 689 "Invalid hash for xattr (%s) associated " 690 "with %k", name, INODE_PKEY(inode)); 691 err = -EIO; 692 } 693 694 out_unlock: 695 up_read(&REISERFS_I(inode)->i_xattr_sem); 696 dput(dentry); 697 698 out: 699 return err; 700 } 701 702 /* 703 * In order to implement different sets of xattr operations for each xattr 704 * prefix with the generic xattr API, a filesystem should create a 705 * null-terminated array of struct xattr_handler (one for each prefix) and 706 * hang a pointer to it off of the s_xattr field of the superblock. 707 * 708 * The generic_fooxattr() functions will use this list to dispatch xattr 709 * operations to the correct xattr_handler. 710 */ 711 #define for_each_xattr_handler(handlers, handler) \ 712 for ((handler) = *(handlers)++; \ 713 (handler) != NULL; \ 714 (handler) = *(handlers)++) 715 716 /* This is the implementation for the xattr plugin infrastructure */ 717 static inline struct xattr_handler * 718 find_xattr_handler_prefix(struct xattr_handler **handlers, 719 const char *name) 720 { 721 struct xattr_handler *xah; 722 723 if (!handlers) 724 return NULL; 725 726 for_each_xattr_handler(handlers, xah) { 727 if (strncmp(xah->prefix, name, strlen(xah->prefix)) == 0) 728 break; 729 } 730 731 return xah; 732 } 733 734 735 /* 736 * Inode operation getxattr() 737 */ 738 ssize_t 739 reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer, 740 size_t size) 741 { 742 struct inode *inode = dentry->d_inode; 743 struct xattr_handler *handler; 744 745 handler = find_xattr_handler_prefix(inode->i_sb->s_xattr, name); 746 747 if (!handler || get_inode_sd_version(inode) == STAT_DATA_V1) 748 return -EOPNOTSUPP; 749 750 return handler->get(inode, name, buffer, size); 751 } 752 753 /* 754 * Inode operation setxattr() 755 * 756 * dentry->d_inode->i_mutex down 757 */ 758 int 759 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value, 760 size_t size, int flags) 761 { 762 struct inode *inode = dentry->d_inode; 763 struct xattr_handler *handler; 764 765 handler = find_xattr_handler_prefix(inode->i_sb->s_xattr, name); 766 767 if (!handler || get_inode_sd_version(inode) == STAT_DATA_V1) 768 return -EOPNOTSUPP; 769 770 return handler->set(inode, name, value, size, flags); 771 } 772 773 /* 774 * Inode operation removexattr() 775 * 776 * dentry->d_inode->i_mutex down 777 */ 778 int reiserfs_removexattr(struct dentry *dentry, const char *name) 779 { 780 struct inode *inode = dentry->d_inode; 781 struct xattr_handler *handler; 782 handler = find_xattr_handler_prefix(inode->i_sb->s_xattr, name); 783 784 if (!handler || get_inode_sd_version(inode) == STAT_DATA_V1) 785 return -EOPNOTSUPP; 786 787 return handler->set(inode, name, NULL, 0, XATTR_REPLACE); 788 } 789 790 struct listxattr_buf { 791 size_t size; 792 size_t pos; 793 char *buf; 794 struct inode *inode; 795 }; 796 797 static int listxattr_filler(void *buf, const char *name, int namelen, 798 loff_t offset, u64 ino, unsigned int d_type) 799 { 800 struct listxattr_buf *b = (struct listxattr_buf *)buf; 801 size_t size; 802 if (name[0] != '.' || 803 (namelen != 1 && (name[1] != '.' || namelen != 2))) { 804 struct xattr_handler *handler; 805 handler = find_xattr_handler_prefix(b->inode->i_sb->s_xattr, 806 name); 807 if (!handler) /* Unsupported xattr name */ 808 return 0; 809 if (b->buf) { 810 size = handler->list(b->inode, b->buf + b->pos, 811 b->size, name, namelen); 812 if (size > b->size) 813 return -ERANGE; 814 } else { 815 size = handler->list(b->inode, NULL, 0, name, namelen); 816 } 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 loff_t pos = 0; 835 struct listxattr_buf buf = { 836 .inode = dentry->d_inode, 837 .buf = buffer, 838 .size = buffer ? size : 0, 839 }; 840 841 if (!dentry->d_inode) 842 return -EINVAL; 843 844 if (!dentry->d_sb->s_xattr || 845 get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1) 846 return -EOPNOTSUPP; 847 848 dir = open_xa_dir(dentry->d_inode, 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 mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_XATTR); 857 err = reiserfs_readdir_dentry(dir, &buf, listxattr_filler, &pos); 858 mutex_unlock(&dir->d_inode->i_mutex); 859 860 if (!err) 861 err = buf.pos; 862 863 dput(dir); 864 out: 865 return err; 866 } 867 868 static int reiserfs_check_acl(struct inode *inode, int mask) 869 { 870 struct posix_acl *acl; 871 int error = -EAGAIN; /* do regular unix permission checks by default */ 872 873 acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS); 874 875 if (acl) { 876 if (!IS_ERR(acl)) { 877 error = posix_acl_permission(inode, acl, mask); 878 posix_acl_release(acl); 879 } else if (PTR_ERR(acl) != -ENODATA) 880 error = PTR_ERR(acl); 881 } 882 883 return error; 884 } 885 886 static int create_privroot(struct dentry *dentry) 887 { 888 int err; 889 struct inode *inode = dentry->d_parent->d_inode; 890 WARN_ON_ONCE(!mutex_is_locked(&inode->i_mutex)); 891 892 err = xattr_mkdir(inode, dentry, 0700); 893 if (err || !dentry->d_inode) { 894 reiserfs_warning(dentry->d_sb, "jdm-20006", 895 "xattrs/ACLs enabled and couldn't " 896 "find/create .reiserfs_priv. " 897 "Failing mount."); 898 return -EOPNOTSUPP; 899 } 900 901 dentry->d_inode->i_flags |= S_PRIVATE; 902 reiserfs_info(dentry->d_sb, "Created %s - reserved for xattr " 903 "storage.\n", PRIVROOT_NAME); 904 905 return 0; 906 } 907 908 #else 909 int __init reiserfs_xattr_register_handlers(void) { return 0; } 910 void reiserfs_xattr_unregister_handlers(void) {} 911 static int create_privroot(struct dentry *dentry) { return 0; } 912 #endif 913 914 /* Actual operations that are exported to VFS-land */ 915 struct xattr_handler *reiserfs_xattr_handlers[] = { 916 #ifdef CONFIG_REISERFS_FS_XATTR 917 &reiserfs_xattr_user_handler, 918 &reiserfs_xattr_trusted_handler, 919 #endif 920 #ifdef CONFIG_REISERFS_FS_SECURITY 921 &reiserfs_xattr_security_handler, 922 #endif 923 #ifdef CONFIG_REISERFS_FS_POSIX_ACL 924 &reiserfs_posix_acl_access_handler, 925 &reiserfs_posix_acl_default_handler, 926 #endif 927 NULL 928 }; 929 930 static int xattr_mount_check(struct super_block *s) 931 { 932 /* We need generation numbers to ensure that the oid mapping is correct 933 * v3.5 filesystems don't have them. */ 934 if (old_format_only(s)) { 935 if (reiserfs_xattrs_optional(s)) { 936 /* Old format filesystem, but optional xattrs have 937 * been enabled. Error out. */ 938 reiserfs_warning(s, "jdm-2005", 939 "xattrs/ACLs not supported " 940 "on pre-v3.6 format filesystems. " 941 "Failing mount."); 942 return -EOPNOTSUPP; 943 } 944 } 945 946 return 0; 947 } 948 949 int reiserfs_permission(struct inode *inode, int mask) 950 { 951 /* 952 * We don't do permission checks on the internal objects. 953 * Permissions are determined by the "owning" object. 954 */ 955 if (IS_PRIVATE(inode)) 956 return 0; 957 958 #ifdef CONFIG_REISERFS_FS_XATTR 959 /* 960 * Stat data v1 doesn't support ACLs. 961 */ 962 if (get_inode_sd_version(inode) != STAT_DATA_V1) 963 return generic_permission(inode, mask, reiserfs_check_acl); 964 #endif 965 return generic_permission(inode, mask, NULL); 966 } 967 968 /* This will catch lookups from the fs root to .reiserfs_priv */ 969 static int 970 xattr_lookup_poison(struct dentry *dentry, struct qstr *q1, struct qstr *name) 971 { 972 struct dentry *priv_root = REISERFS_SB(dentry->d_sb)->priv_root; 973 if (container_of(q1, struct dentry, d_name) == priv_root) 974 return -ENOENT; 975 if (q1->len == name->len && 976 !memcmp(q1->name, name->name, name->len)) 977 return 0; 978 return 1; 979 } 980 981 static const struct dentry_operations xattr_lookup_poison_ops = { 982 .d_compare = xattr_lookup_poison, 983 }; 984 985 int reiserfs_lookup_privroot(struct super_block *s) 986 { 987 struct dentry *dentry; 988 int err = 0; 989 990 /* If we don't have the privroot located yet - go find it */ 991 reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s); 992 dentry = lookup_one_len(PRIVROOT_NAME, s->s_root, 993 strlen(PRIVROOT_NAME)); 994 if (!IS_ERR(dentry)) { 995 REISERFS_SB(s)->priv_root = dentry; 996 if (!reiserfs_expose_privroot(s)) 997 s->s_root->d_op = &xattr_lookup_poison_ops; 998 if (dentry->d_inode) 999 dentry->d_inode->i_flags |= S_PRIVATE; 1000 } else 1001 err = PTR_ERR(dentry); 1002 mutex_unlock(&s->s_root->d_inode->i_mutex); 1003 1004 return err; 1005 } 1006 1007 /* We need to take a copy of the mount flags since things like 1008 * MS_RDONLY don't get set until *after* we're called. 1009 * mount_flags != mount_options */ 1010 int reiserfs_xattr_init(struct super_block *s, int mount_flags) 1011 { 1012 int err = 0; 1013 struct dentry *privroot = REISERFS_SB(s)->priv_root; 1014 1015 err = xattr_mount_check(s); 1016 if (err) 1017 goto error; 1018 1019 if (!privroot->d_inode && !(mount_flags & MS_RDONLY)) { 1020 reiserfs_mutex_lock_safe(&s->s_root->d_inode->i_mutex, s); 1021 err = create_privroot(REISERFS_SB(s)->priv_root); 1022 mutex_unlock(&s->s_root->d_inode->i_mutex); 1023 } 1024 1025 if (privroot->d_inode) { 1026 s->s_xattr = reiserfs_xattr_handlers; 1027 reiserfs_mutex_lock_safe(&privroot->d_inode->i_mutex, s); 1028 if (!REISERFS_SB(s)->xattr_root) { 1029 struct dentry *dentry; 1030 dentry = lookup_one_len(XAROOT_NAME, privroot, 1031 strlen(XAROOT_NAME)); 1032 if (!IS_ERR(dentry)) 1033 REISERFS_SB(s)->xattr_root = dentry; 1034 else 1035 err = PTR_ERR(dentry); 1036 } 1037 mutex_unlock(&privroot->d_inode->i_mutex); 1038 } 1039 1040 error: 1041 if (err) { 1042 clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt)); 1043 clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt)); 1044 } 1045 1046 /* The super_block MS_POSIXACL must mirror the (no)acl mount option. */ 1047 if (reiserfs_posixacl(s)) 1048 s->s_flags |= MS_POSIXACL; 1049 else 1050 s->s_flags &= ~MS_POSIXACL; 1051 1052 return err; 1053 } 1054