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