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