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