xref: /openbmc/linux/fs/reiserfs/xattr.c (revision 22246614)
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 
32 #include <linux/reiserfs_fs.h>
33 #include <linux/capability.h>
34 #include <linux/dcache.h>
35 #include <linux/namei.h>
36 #include <linux/errno.h>
37 #include <linux/fs.h>
38 #include <linux/file.h>
39 #include <linux/pagemap.h>
40 #include <linux/xattr.h>
41 #include <linux/reiserfs_xattr.h>
42 #include <linux/reiserfs_acl.h>
43 #include <asm/uaccess.h>
44 #include <net/checksum.h>
45 #include <linux/smp_lock.h>
46 #include <linux/stat.h>
47 
48 #define FL_READONLY 128
49 #define FL_DIR_SEM_HELD 256
50 #define PRIVROOT_NAME ".reiserfs_priv"
51 #define XAROOT_NAME   "xattrs"
52 
53 static struct reiserfs_xattr_handler *find_xattr_handler_prefix(const char
54 								*prefix);
55 
56 /* Returns the dentry referring to the root of the extended attribute
57  * directory tree. If it has already been retrieved, it is used. If it
58  * hasn't been created and the flags indicate creation is allowed, we
59  * attempt to create it. On error, we return a pointer-encoded error.
60  */
61 static struct dentry *get_xa_root(struct super_block *sb, int flags)
62 {
63 	struct dentry *privroot = dget(REISERFS_SB(sb)->priv_root);
64 	struct dentry *xaroot;
65 
66 	/* This needs to be created at mount-time */
67 	if (!privroot)
68 		return ERR_PTR(-ENODATA);
69 
70 	mutex_lock_nested(&privroot->d_inode->i_mutex, I_MUTEX_XATTR);
71 	if (REISERFS_SB(sb)->xattr_root) {
72 		xaroot = dget(REISERFS_SB(sb)->xattr_root);
73 		goto out;
74 	}
75 
76 	xaroot = lookup_one_len(XAROOT_NAME, privroot, strlen(XAROOT_NAME));
77 	if (IS_ERR(xaroot)) {
78 		goto out;
79 	} else if (!xaroot->d_inode) {
80 		int err = -ENODATA;
81 		if (flags == 0 || flags & XATTR_CREATE)
82 			err = privroot->d_inode->i_op->mkdir(privroot->d_inode,
83 			                                     xaroot, 0700);
84 		if (err) {
85 			dput(xaroot);
86 			xaroot = ERR_PTR(err);
87 			goto out;
88 		}
89 	}
90 	REISERFS_SB(sb)->xattr_root = dget(xaroot);
91 
92       out:
93 	mutex_unlock(&privroot->d_inode->i_mutex);
94 	dput(privroot);
95 	return xaroot;
96 }
97 
98 /* Opens the directory corresponding to the inode's extended attribute store.
99  * If flags allow, the tree to the directory may be created. If creation is
100  * prohibited, -ENODATA is returned. */
101 static struct dentry *open_xa_dir(const struct inode *inode, int flags)
102 {
103 	struct dentry *xaroot, *xadir;
104 	char namebuf[17];
105 
106 	xaroot = get_xa_root(inode->i_sb, flags);
107 	if (IS_ERR(xaroot))
108 		return xaroot;
109 
110 	/* ok, we have xaroot open */
111 	snprintf(namebuf, sizeof(namebuf), "%X.%X",
112 		 le32_to_cpu(INODE_PKEY(inode)->k_objectid),
113 		 inode->i_generation);
114 	xadir = lookup_one_len(namebuf, xaroot, strlen(namebuf));
115 	if (IS_ERR(xadir)) {
116 		dput(xaroot);
117 		return xadir;
118 	}
119 
120 	if (!xadir->d_inode) {
121 		int err;
122 		if (flags == 0 || flags & XATTR_CREATE) {
123 			/* Although there is nothing else trying to create this directory,
124 			 * another directory with the same hash may be created, so we need
125 			 * to protect against that */
126 			err =
127 			    xaroot->d_inode->i_op->mkdir(xaroot->d_inode, xadir,
128 							 0700);
129 			if (err) {
130 				dput(xaroot);
131 				dput(xadir);
132 				return ERR_PTR(err);
133 			}
134 		}
135 		if (!xadir->d_inode) {
136 			dput(xaroot);
137 			dput(xadir);
138 			return ERR_PTR(-ENODATA);
139 		}
140 	}
141 
142 	dput(xaroot);
143 	return xadir;
144 }
145 
146 /* Returns a dentry corresponding to a specific extended attribute file
147  * for the inode. If flags allow, the file is created. Otherwise, a
148  * valid or negative dentry, or an error is returned. */
149 static struct dentry *get_xa_file_dentry(const struct inode *inode,
150 					 const char *name, int flags)
151 {
152 	struct dentry *xadir, *xafile;
153 	int err = 0;
154 
155 	xadir = open_xa_dir(inode, flags);
156 	if (IS_ERR(xadir)) {
157 		return ERR_CAST(xadir);
158 	} else if (xadir && !xadir->d_inode) {
159 		dput(xadir);
160 		return ERR_PTR(-ENODATA);
161 	}
162 
163 	xafile = lookup_one_len(name, xadir, strlen(name));
164 	if (IS_ERR(xafile)) {
165 		dput(xadir);
166 		return ERR_CAST(xafile);
167 	}
168 
169 	if (xafile->d_inode) {	/* file exists */
170 		if (flags & XATTR_CREATE) {
171 			err = -EEXIST;
172 			dput(xafile);
173 			goto out;
174 		}
175 	} else if (flags & XATTR_REPLACE || flags & FL_READONLY) {
176 		goto out;
177 	} else {
178 		/* inode->i_mutex is down, so nothing else can try to create
179 		 * the same xattr */
180 		err = xadir->d_inode->i_op->create(xadir->d_inode, xafile,
181 						   0700 | S_IFREG, NULL);
182 
183 		if (err) {
184 			dput(xafile);
185 			goto out;
186 		}
187 	}
188 
189       out:
190 	dput(xadir);
191 	if (err)
192 		xafile = ERR_PTR(err);
193 	else if (!xafile->d_inode) {
194 		dput(xafile);
195 		xafile = ERR_PTR(-ENODATA);
196 	}
197 	return xafile;
198 }
199 
200 /*
201  * this is very similar to fs/reiserfs/dir.c:reiserfs_readdir, but
202  * we need to drop the path before calling the filldir struct.  That
203  * would be a big performance hit to the non-xattr case, so I've copied
204  * the whole thing for now. --clm
205  *
206  * the big difference is that I go backwards through the directory,
207  * and don't mess with f->f_pos, but the idea is the same.  Do some
208  * action on each and every entry in the directory.
209  *
210  * we're called with i_mutex held, so there are no worries about the directory
211  * changing underneath us.
212  */
213 static int __xattr_readdir(struct inode *inode, void *dirent, filldir_t filldir)
214 {
215 	struct cpu_key pos_key;	/* key of current position in the directory (key of directory entry) */
216 	INITIALIZE_PATH(path_to_entry);
217 	struct buffer_head *bh;
218 	int entry_num;
219 	struct item_head *ih, tmp_ih;
220 	int search_res;
221 	char *local_buf;
222 	loff_t next_pos;
223 	char small_buf[32];	/* avoid kmalloc if we can */
224 	struct reiserfs_de_head *deh;
225 	int d_reclen;
226 	char *d_name;
227 	off_t d_off;
228 	ino_t d_ino;
229 	struct reiserfs_dir_entry de;
230 
231 	/* form key for search the next directory entry using f_pos field of
232 	   file structure */
233 	next_pos = max_reiserfs_offset(inode);
234 
235 	while (1) {
236 	      research:
237 		if (next_pos <= DOT_DOT_OFFSET)
238 			break;
239 		make_cpu_key(&pos_key, inode, next_pos, TYPE_DIRENTRY, 3);
240 
241 		search_res =
242 		    search_by_entry_key(inode->i_sb, &pos_key, &path_to_entry,
243 					&de);
244 		if (search_res == IO_ERROR) {
245 			// FIXME: we could just skip part of directory which could
246 			// not be read
247 			pathrelse(&path_to_entry);
248 			return -EIO;
249 		}
250 
251 		if (search_res == NAME_NOT_FOUND)
252 			de.de_entry_num--;
253 
254 		set_de_name_and_namelen(&de);
255 		entry_num = de.de_entry_num;
256 		deh = &(de.de_deh[entry_num]);
257 
258 		bh = de.de_bh;
259 		ih = de.de_ih;
260 
261 		if (!is_direntry_le_ih(ih)) {
262 			reiserfs_warning(inode->i_sb, "not direntry %h", ih);
263 			break;
264 		}
265 		copy_item_head(&tmp_ih, ih);
266 
267 		/* we must have found item, that is item of this directory, */
268 		RFALSE(COMP_SHORT_KEYS(&(ih->ih_key), &pos_key),
269 		       "vs-9000: found item %h does not match to dir we readdir %K",
270 		       ih, &pos_key);
271 
272 		if (deh_offset(deh) <= DOT_DOT_OFFSET) {
273 			break;
274 		}
275 
276 		/* look for the previous entry in the directory */
277 		next_pos = deh_offset(deh) - 1;
278 
279 		if (!de_visible(deh))
280 			/* it is hidden entry */
281 			continue;
282 
283 		d_reclen = entry_length(bh, ih, entry_num);
284 		d_name = B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh);
285 		d_off = deh_offset(deh);
286 		d_ino = deh_objectid(deh);
287 
288 		if (!d_name[d_reclen - 1])
289 			d_reclen = strlen(d_name);
290 
291 		if (d_reclen > REISERFS_MAX_NAME(inode->i_sb->s_blocksize)) {
292 			/* too big to send back to VFS */
293 			continue;
294 		}
295 
296 		/* Ignore the .reiserfs_priv entry */
297 		if (reiserfs_xattrs(inode->i_sb) &&
298 		    !old_format_only(inode->i_sb) &&
299 		    deh_objectid(deh) ==
300 		    le32_to_cpu(INODE_PKEY
301 				(REISERFS_SB(inode->i_sb)->priv_root->d_inode)->
302 				k_objectid))
303 			continue;
304 
305 		if (d_reclen <= 32) {
306 			local_buf = small_buf;
307 		} else {
308 			local_buf = kmalloc(d_reclen, GFP_NOFS);
309 			if (!local_buf) {
310 				pathrelse(&path_to_entry);
311 				return -ENOMEM;
312 			}
313 			if (item_moved(&tmp_ih, &path_to_entry)) {
314 				kfree(local_buf);
315 
316 				/* sigh, must retry.  Do this same offset again */
317 				next_pos = d_off;
318 				goto research;
319 			}
320 		}
321 
322 		// Note, that we copy name to user space via temporary
323 		// buffer (local_buf) because filldir will block if
324 		// user space buffer is swapped out. At that time
325 		// entry can move to somewhere else
326 		memcpy(local_buf, d_name, d_reclen);
327 
328 		/* the filldir function might need to start transactions,
329 		 * or do who knows what.  Release the path now that we've
330 		 * copied all the important stuff out of the deh
331 		 */
332 		pathrelse(&path_to_entry);
333 
334 		if (filldir(dirent, local_buf, d_reclen, d_off, d_ino,
335 			    DT_UNKNOWN) < 0) {
336 			if (local_buf != small_buf) {
337 				kfree(local_buf);
338 			}
339 			goto end;
340 		}
341 		if (local_buf != small_buf) {
342 			kfree(local_buf);
343 		}
344 	}			/* while */
345 
346       end:
347 	pathrelse(&path_to_entry);
348 	return 0;
349 }
350 
351 /*
352  * this could be done with dedicated readdir ops for the xattr files,
353  * but I want to get something working asap
354  * this is stolen from vfs_readdir
355  *
356  */
357 static
358 int xattr_readdir(struct inode *inode, filldir_t filler, void *buf)
359 {
360 	int res = -ENOENT;
361 	mutex_lock_nested(&inode->i_mutex, I_MUTEX_XATTR);
362 	if (!IS_DEADDIR(inode)) {
363 		lock_kernel();
364 		res = __xattr_readdir(inode, buf, filler);
365 		unlock_kernel();
366 	}
367 	mutex_unlock(&inode->i_mutex);
368 	return res;
369 }
370 
371 /* Internal operations on file data */
372 static inline void reiserfs_put_page(struct page *page)
373 {
374 	kunmap(page);
375 	page_cache_release(page);
376 }
377 
378 static struct page *reiserfs_get_page(struct inode *dir, unsigned long n)
379 {
380 	struct address_space *mapping = dir->i_mapping;
381 	struct page *page;
382 	/* We can deadlock if we try to free dentries,
383 	   and an unlink/rmdir has just occured - GFP_NOFS avoids this */
384 	mapping_set_gfp_mask(mapping, GFP_NOFS);
385 	page = read_mapping_page(mapping, n, NULL);
386 	if (!IS_ERR(page)) {
387 		kmap(page);
388 		if (PageError(page))
389 			goto fail;
390 	}
391 	return page;
392 
393       fail:
394 	reiserfs_put_page(page);
395 	return ERR_PTR(-EIO);
396 }
397 
398 static inline __u32 xattr_hash(const char *msg, int len)
399 {
400 	return csum_partial(msg, len, 0);
401 }
402 
403 int reiserfs_commit_write(struct file *f, struct page *page,
404 			  unsigned from, unsigned to);
405 int reiserfs_prepare_write(struct file *f, struct page *page,
406 			   unsigned from, unsigned to);
407 
408 
409 /* Generic extended attribute operations that can be used by xa plugins */
410 
411 /*
412  * inode->i_mutex: down
413  */
414 int
415 reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
416 		   size_t buffer_size, int flags)
417 {
418 	int err = 0;
419 	struct dentry *dentry;
420 	struct page *page;
421 	char *data;
422 	struct address_space *mapping;
423 	size_t file_pos = 0;
424 	size_t buffer_pos = 0;
425 	struct inode *xinode;
426 	struct iattr newattrs;
427 	__u32 xahash = 0;
428 
429 	if (get_inode_sd_version(inode) == STAT_DATA_V1)
430 		return -EOPNOTSUPP;
431 
432 	/* Empty xattrs are ok, they're just empty files, no hash */
433 	if (buffer && buffer_size)
434 		xahash = xattr_hash(buffer, buffer_size);
435 
436       open_file:
437 	dentry = get_xa_file_dentry(inode, name, flags);
438 	if (IS_ERR(dentry)) {
439 		err = PTR_ERR(dentry);
440 		goto out;
441 	}
442 
443 	xinode = dentry->d_inode;
444 	REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
445 
446 	/* we need to copy it off.. */
447 	if (xinode->i_nlink > 1) {
448 		dput(dentry);
449 		err = reiserfs_xattr_del(inode, name);
450 		if (err < 0)
451 			goto out;
452 		/* We just killed the old one, we're not replacing anymore */
453 		if (flags & XATTR_REPLACE)
454 			flags &= ~XATTR_REPLACE;
455 		goto open_file;
456 	}
457 
458 	/* Resize it so we're ok to write there */
459 	newattrs.ia_size = buffer_size;
460 	newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
461 	mutex_lock_nested(&xinode->i_mutex, I_MUTEX_XATTR);
462 	err = notify_change(dentry, &newattrs);
463 	if (err)
464 		goto out_filp;
465 
466 	mapping = xinode->i_mapping;
467 	while (buffer_pos < buffer_size || buffer_pos == 0) {
468 		size_t chunk;
469 		size_t skip = 0;
470 		size_t page_offset = (file_pos & (PAGE_CACHE_SIZE - 1));
471 		if (buffer_size - buffer_pos > PAGE_CACHE_SIZE)
472 			chunk = PAGE_CACHE_SIZE;
473 		else
474 			chunk = buffer_size - buffer_pos;
475 
476 		page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT);
477 		if (IS_ERR(page)) {
478 			err = PTR_ERR(page);
479 			goto out_filp;
480 		}
481 
482 		lock_page(page);
483 		data = page_address(page);
484 
485 		if (file_pos == 0) {
486 			struct reiserfs_xattr_header *rxh;
487 			skip = file_pos = sizeof(struct reiserfs_xattr_header);
488 			if (chunk + skip > PAGE_CACHE_SIZE)
489 				chunk = PAGE_CACHE_SIZE - skip;
490 			rxh = (struct reiserfs_xattr_header *)data;
491 			rxh->h_magic = cpu_to_le32(REISERFS_XATTR_MAGIC);
492 			rxh->h_hash = cpu_to_le32(xahash);
493 		}
494 
495 		err = reiserfs_prepare_write(NULL, page, page_offset,
496 					    page_offset + chunk + skip);
497 		if (!err) {
498 			if (buffer)
499 				memcpy(data + skip, buffer + buffer_pos, chunk);
500 			err = reiserfs_commit_write(NULL, page, page_offset,
501 						    page_offset + chunk +
502 						    skip);
503 		}
504 		unlock_page(page);
505 		reiserfs_put_page(page);
506 		buffer_pos += chunk;
507 		file_pos += chunk;
508 		skip = 0;
509 		if (err || buffer_size == 0 || !buffer)
510 			break;
511 	}
512 
513 	/* We can't mark the inode dirty if it's not hashed. This is the case
514 	 * when we're inheriting the default ACL. If we dirty it, the inode
515 	 * gets marked dirty, but won't (ever) make it onto the dirty list until
516 	 * it's synced explicitly to clear I_DIRTY. This is bad. */
517 	if (!hlist_unhashed(&inode->i_hash)) {
518 		inode->i_ctime = CURRENT_TIME_SEC;
519 		mark_inode_dirty(inode);
520 	}
521 
522       out_filp:
523 	mutex_unlock(&xinode->i_mutex);
524 	dput(dentry);
525 
526       out:
527 	return err;
528 }
529 
530 /*
531  * inode->i_mutex: down
532  */
533 int
534 reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
535 		   size_t buffer_size)
536 {
537 	ssize_t err = 0;
538 	struct dentry *dentry;
539 	size_t isize;
540 	size_t file_pos = 0;
541 	size_t buffer_pos = 0;
542 	struct page *page;
543 	struct inode *xinode;
544 	__u32 hash = 0;
545 
546 	if (name == NULL)
547 		return -EINVAL;
548 
549 	/* We can't have xattrs attached to v1 items since they don't have
550 	 * generation numbers */
551 	if (get_inode_sd_version(inode) == STAT_DATA_V1)
552 		return -EOPNOTSUPP;
553 
554 	dentry = get_xa_file_dentry(inode, name, FL_READONLY);
555 	if (IS_ERR(dentry)) {
556 		err = PTR_ERR(dentry);
557 		goto out;
558 	}
559 
560 	xinode = dentry->d_inode;
561 	isize = xinode->i_size;
562 	REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
563 
564 	/* Just return the size needed */
565 	if (buffer == NULL) {
566 		err = isize - sizeof(struct reiserfs_xattr_header);
567 		goto out_dput;
568 	}
569 
570 	if (buffer_size < isize - sizeof(struct reiserfs_xattr_header)) {
571 		err = -ERANGE;
572 		goto out_dput;
573 	}
574 
575 	while (file_pos < isize) {
576 		size_t chunk;
577 		char *data;
578 		size_t skip = 0;
579 		if (isize - file_pos > PAGE_CACHE_SIZE)
580 			chunk = PAGE_CACHE_SIZE;
581 		else
582 			chunk = isize - file_pos;
583 
584 		page = reiserfs_get_page(xinode, file_pos >> PAGE_CACHE_SHIFT);
585 		if (IS_ERR(page)) {
586 			err = PTR_ERR(page);
587 			goto out_dput;
588 		}
589 
590 		lock_page(page);
591 		data = page_address(page);
592 		if (file_pos == 0) {
593 			struct reiserfs_xattr_header *rxh =
594 			    (struct reiserfs_xattr_header *)data;
595 			skip = file_pos = sizeof(struct reiserfs_xattr_header);
596 			chunk -= skip;
597 			/* Magic doesn't match up.. */
598 			if (rxh->h_magic != cpu_to_le32(REISERFS_XATTR_MAGIC)) {
599 				unlock_page(page);
600 				reiserfs_put_page(page);
601 				reiserfs_warning(inode->i_sb,
602 						 "Invalid magic for xattr (%s) "
603 						 "associated with %k", name,
604 						 INODE_PKEY(inode));
605 				err = -EIO;
606 				goto out_dput;
607 			}
608 			hash = le32_to_cpu(rxh->h_hash);
609 		}
610 		memcpy(buffer + buffer_pos, data + skip, chunk);
611 		unlock_page(page);
612 		reiserfs_put_page(page);
613 		file_pos += chunk;
614 		buffer_pos += chunk;
615 		skip = 0;
616 	}
617 	err = isize - sizeof(struct reiserfs_xattr_header);
618 
619 	if (xattr_hash(buffer, isize - sizeof(struct reiserfs_xattr_header)) !=
620 	    hash) {
621 		reiserfs_warning(inode->i_sb,
622 				 "Invalid hash for xattr (%s) associated "
623 				 "with %k", name, INODE_PKEY(inode));
624 		err = -EIO;
625 	}
626 
627       out_dput:
628 	dput(dentry);
629 
630       out:
631 	return err;
632 }
633 
634 static int
635 __reiserfs_xattr_del(struct dentry *xadir, const char *name, int namelen)
636 {
637 	struct dentry *dentry;
638 	struct inode *dir = xadir->d_inode;
639 	int err = 0;
640 
641 	dentry = lookup_one_len(name, xadir, namelen);
642 	if (IS_ERR(dentry)) {
643 		err = PTR_ERR(dentry);
644 		goto out;
645 	} else if (!dentry->d_inode) {
646 		err = -ENODATA;
647 		goto out_file;
648 	}
649 
650 	/* Skip directories.. */
651 	if (S_ISDIR(dentry->d_inode->i_mode))
652 		goto out_file;
653 
654 	if (!is_reiserfs_priv_object(dentry->d_inode)) {
655 		reiserfs_warning(dir->i_sb, "OID %08x [%.*s/%.*s] doesn't have "
656 				 "priv flag set [parent is %sset].",
657 				 le32_to_cpu(INODE_PKEY(dentry->d_inode)->
658 					     k_objectid), xadir->d_name.len,
659 				 xadir->d_name.name, namelen, name,
660 				 is_reiserfs_priv_object(xadir->
661 							 d_inode) ? "" :
662 				 "not ");
663 		dput(dentry);
664 		return -EIO;
665 	}
666 
667 	err = dir->i_op->unlink(dir, dentry);
668 	if (!err)
669 		d_delete(dentry);
670 
671       out_file:
672 	dput(dentry);
673 
674       out:
675 	return err;
676 }
677 
678 int reiserfs_xattr_del(struct inode *inode, const char *name)
679 {
680 	struct dentry *dir;
681 	int err;
682 
683 	dir = open_xa_dir(inode, FL_READONLY);
684 	if (IS_ERR(dir)) {
685 		err = PTR_ERR(dir);
686 		goto out;
687 	}
688 
689 	err = __reiserfs_xattr_del(dir, name, strlen(name));
690 	dput(dir);
691 
692 	if (!err) {
693 		inode->i_ctime = CURRENT_TIME_SEC;
694 		mark_inode_dirty(inode);
695 	}
696 
697       out:
698 	return err;
699 }
700 
701 /* The following are side effects of other operations that aren't explicitly
702  * modifying extended attributes. This includes operations such as permissions
703  * or ownership changes, object deletions, etc. */
704 
705 static int
706 reiserfs_delete_xattrs_filler(void *buf, const char *name, int namelen,
707 			      loff_t offset, u64 ino, unsigned int d_type)
708 {
709 	struct dentry *xadir = (struct dentry *)buf;
710 
711 	return __reiserfs_xattr_del(xadir, name, namelen);
712 
713 }
714 
715 /* This is called w/ inode->i_mutex downed */
716 int reiserfs_delete_xattrs(struct inode *inode)
717 {
718 	struct dentry *dir, *root;
719 	int err = 0;
720 
721 	/* Skip out, an xattr has no xattrs associated with it */
722 	if (is_reiserfs_priv_object(inode) ||
723 	    get_inode_sd_version(inode) == STAT_DATA_V1 ||
724 	    !reiserfs_xattrs(inode->i_sb)) {
725 		return 0;
726 	}
727 	reiserfs_read_lock_xattrs(inode->i_sb);
728 	dir = open_xa_dir(inode, FL_READONLY);
729 	reiserfs_read_unlock_xattrs(inode->i_sb);
730 	if (IS_ERR(dir)) {
731 		err = PTR_ERR(dir);
732 		goto out;
733 	} else if (!dir->d_inode) {
734 		dput(dir);
735 		return 0;
736 	}
737 
738 	lock_kernel();
739 	err = xattr_readdir(dir->d_inode, reiserfs_delete_xattrs_filler, dir);
740 	if (err) {
741 		unlock_kernel();
742 		goto out_dir;
743 	}
744 
745 	/* Leftovers besides . and .. -- that's not good. */
746 	if (dir->d_inode->i_nlink <= 2) {
747 		root = get_xa_root(inode->i_sb, XATTR_REPLACE);
748 		reiserfs_write_lock_xattrs(inode->i_sb);
749 		err = vfs_rmdir(root->d_inode, dir);
750 		reiserfs_write_unlock_xattrs(inode->i_sb);
751 		dput(root);
752 	} else {
753 		reiserfs_warning(inode->i_sb,
754 				 "Couldn't remove all entries in directory");
755 	}
756 	unlock_kernel();
757 
758       out_dir:
759 	dput(dir);
760 
761       out:
762 	if (!err)
763 		REISERFS_I(inode)->i_flags =
764 		    REISERFS_I(inode)->i_flags & ~i_has_xattr_dir;
765 	return err;
766 }
767 
768 struct reiserfs_chown_buf {
769 	struct inode *inode;
770 	struct dentry *xadir;
771 	struct iattr *attrs;
772 };
773 
774 /* XXX: If there is a better way to do this, I'd love to hear about it */
775 static int
776 reiserfs_chown_xattrs_filler(void *buf, const char *name, int namelen,
777 			     loff_t offset, u64 ino, unsigned int d_type)
778 {
779 	struct reiserfs_chown_buf *chown_buf = (struct reiserfs_chown_buf *)buf;
780 	struct dentry *xafile, *xadir = chown_buf->xadir;
781 	struct iattr *attrs = chown_buf->attrs;
782 	int err = 0;
783 
784 	xafile = lookup_one_len(name, xadir, namelen);
785 	if (IS_ERR(xafile))
786 		return PTR_ERR(xafile);
787 	else if (!xafile->d_inode) {
788 		dput(xafile);
789 		return -ENODATA;
790 	}
791 
792 	if (!S_ISDIR(xafile->d_inode->i_mode))
793 		err = notify_change(xafile, attrs);
794 	dput(xafile);
795 
796 	return err;
797 }
798 
799 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
800 {
801 	struct dentry *dir;
802 	int err = 0;
803 	struct reiserfs_chown_buf buf;
804 	unsigned int ia_valid = attrs->ia_valid;
805 
806 	/* Skip out, an xattr has no xattrs associated with it */
807 	if (is_reiserfs_priv_object(inode) ||
808 	    get_inode_sd_version(inode) == STAT_DATA_V1 ||
809 	    !reiserfs_xattrs(inode->i_sb)) {
810 		return 0;
811 	}
812 	reiserfs_read_lock_xattrs(inode->i_sb);
813 	dir = open_xa_dir(inode, FL_READONLY);
814 	reiserfs_read_unlock_xattrs(inode->i_sb);
815 	if (IS_ERR(dir)) {
816 		if (PTR_ERR(dir) != -ENODATA)
817 			err = PTR_ERR(dir);
818 		goto out;
819 	} else if (!dir->d_inode) {
820 		dput(dir);
821 		goto out;
822 	}
823 
824 	lock_kernel();
825 
826 	attrs->ia_valid &= (ATTR_UID | ATTR_GID | ATTR_CTIME);
827 	buf.xadir = dir;
828 	buf.attrs = attrs;
829 	buf.inode = inode;
830 
831 	err = xattr_readdir(dir->d_inode, reiserfs_chown_xattrs_filler, &buf);
832 	if (err) {
833 		unlock_kernel();
834 		goto out_dir;
835 	}
836 
837 	err = notify_change(dir, attrs);
838 	unlock_kernel();
839 
840       out_dir:
841 	dput(dir);
842 
843       out:
844 	attrs->ia_valid = ia_valid;
845 	return err;
846 }
847 
848 /* Actual operations that are exported to VFS-land */
849 
850 /*
851  * Inode operation getxattr()
852  * Preliminary locking: we down dentry->d_inode->i_mutex
853  */
854 ssize_t
855 reiserfs_getxattr(struct dentry * dentry, const char *name, void *buffer,
856 		  size_t size)
857 {
858 	struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
859 	int err;
860 
861 	if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
862 	    get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
863 		return -EOPNOTSUPP;
864 
865 	reiserfs_read_lock_xattr_i(dentry->d_inode);
866 	reiserfs_read_lock_xattrs(dentry->d_sb);
867 	err = xah->get(dentry->d_inode, name, buffer, size);
868 	reiserfs_read_unlock_xattrs(dentry->d_sb);
869 	reiserfs_read_unlock_xattr_i(dentry->d_inode);
870 	return err;
871 }
872 
873 /*
874  * Inode operation setxattr()
875  *
876  * dentry->d_inode->i_mutex down
877  */
878 int
879 reiserfs_setxattr(struct dentry *dentry, const char *name, const void *value,
880 		  size_t size, int flags)
881 {
882 	struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
883 	int err;
884 	int lock;
885 
886 	if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
887 	    get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
888 		return -EOPNOTSUPP;
889 
890 	reiserfs_write_lock_xattr_i(dentry->d_inode);
891 	lock = !has_xattr_dir(dentry->d_inode);
892 	if (lock)
893 		reiserfs_write_lock_xattrs(dentry->d_sb);
894 	else
895 		reiserfs_read_lock_xattrs(dentry->d_sb);
896 	err = xah->set(dentry->d_inode, name, value, size, flags);
897 	if (lock)
898 		reiserfs_write_unlock_xattrs(dentry->d_sb);
899 	else
900 		reiserfs_read_unlock_xattrs(dentry->d_sb);
901 	reiserfs_write_unlock_xattr_i(dentry->d_inode);
902 	return err;
903 }
904 
905 /*
906  * Inode operation removexattr()
907  *
908  * dentry->d_inode->i_mutex down
909  */
910 int reiserfs_removexattr(struct dentry *dentry, const char *name)
911 {
912 	int err;
913 	struct reiserfs_xattr_handler *xah = find_xattr_handler_prefix(name);
914 
915 	if (!xah || !reiserfs_xattrs(dentry->d_sb) ||
916 	    get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
917 		return -EOPNOTSUPP;
918 
919 	reiserfs_write_lock_xattr_i(dentry->d_inode);
920 	reiserfs_read_lock_xattrs(dentry->d_sb);
921 
922 	/* Deletion pre-operation */
923 	if (xah->del) {
924 		err = xah->del(dentry->d_inode, name);
925 		if (err)
926 			goto out;
927 	}
928 
929 	err = reiserfs_xattr_del(dentry->d_inode, name);
930 
931 	dentry->d_inode->i_ctime = CURRENT_TIME_SEC;
932 	mark_inode_dirty(dentry->d_inode);
933 
934       out:
935 	reiserfs_read_unlock_xattrs(dentry->d_sb);
936 	reiserfs_write_unlock_xattr_i(dentry->d_inode);
937 	return err;
938 }
939 
940 /* This is what filldir will use:
941  * r_pos will always contain the amount of space required for the entire
942  * list. If r_pos becomes larger than r_size, we need more space and we
943  * return an error indicating this. If r_pos is less than r_size, then we've
944  * filled the buffer successfully and we return success */
945 struct reiserfs_listxattr_buf {
946 	int r_pos;
947 	int r_size;
948 	char *r_buf;
949 	struct inode *r_inode;
950 };
951 
952 static int
953 reiserfs_listxattr_filler(void *buf, const char *name, int namelen,
954 			  loff_t offset, u64 ino, unsigned int d_type)
955 {
956 	struct reiserfs_listxattr_buf *b = (struct reiserfs_listxattr_buf *)buf;
957 	int len = 0;
958 	if (name[0] != '.'
959 	    || (namelen != 1 && (name[1] != '.' || namelen != 2))) {
960 		struct reiserfs_xattr_handler *xah =
961 		    find_xattr_handler_prefix(name);
962 		if (!xah)
963 			return 0;	/* Unsupported xattr name, skip it */
964 
965 		/* We call ->list() twice because the operation isn't required to just
966 		 * return the name back - we want to make sure we have enough space */
967 		len += xah->list(b->r_inode, name, namelen, NULL);
968 
969 		if (len) {
970 			if (b->r_pos + len + 1 <= b->r_size) {
971 				char *p = b->r_buf + b->r_pos;
972 				p += xah->list(b->r_inode, name, namelen, p);
973 				*p++ = '\0';
974 			}
975 			b->r_pos += len + 1;
976 		}
977 	}
978 
979 	return 0;
980 }
981 
982 /*
983  * Inode operation listxattr()
984  *
985  * Preliminary locking: we down dentry->d_inode->i_mutex
986  */
987 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
988 {
989 	struct dentry *dir;
990 	int err = 0;
991 	struct reiserfs_listxattr_buf buf;
992 
993 	if (!dentry->d_inode)
994 		return -EINVAL;
995 
996 	if (!reiserfs_xattrs(dentry->d_sb) ||
997 	    get_inode_sd_version(dentry->d_inode) == STAT_DATA_V1)
998 		return -EOPNOTSUPP;
999 
1000 	reiserfs_read_lock_xattr_i(dentry->d_inode);
1001 	reiserfs_read_lock_xattrs(dentry->d_sb);
1002 	dir = open_xa_dir(dentry->d_inode, FL_READONLY);
1003 	reiserfs_read_unlock_xattrs(dentry->d_sb);
1004 	if (IS_ERR(dir)) {
1005 		err = PTR_ERR(dir);
1006 		if (err == -ENODATA)
1007 			err = 0;	/* Not an error if there aren't any xattrs */
1008 		goto out;
1009 	}
1010 
1011 	buf.r_buf = buffer;
1012 	buf.r_size = buffer ? size : 0;
1013 	buf.r_pos = 0;
1014 	buf.r_inode = dentry->d_inode;
1015 
1016 	REISERFS_I(dentry->d_inode)->i_flags |= i_has_xattr_dir;
1017 
1018 	err = xattr_readdir(dir->d_inode, reiserfs_listxattr_filler, &buf);
1019 	if (err)
1020 		goto out_dir;
1021 
1022 	if (buf.r_pos > buf.r_size && buffer != NULL)
1023 		err = -ERANGE;
1024 	else
1025 		err = buf.r_pos;
1026 
1027       out_dir:
1028 	dput(dir);
1029 
1030       out:
1031 	reiserfs_read_unlock_xattr_i(dentry->d_inode);
1032 	return err;
1033 }
1034 
1035 /* This is the implementation for the xattr plugin infrastructure */
1036 static LIST_HEAD(xattr_handlers);
1037 static DEFINE_RWLOCK(handler_lock);
1038 
1039 static struct reiserfs_xattr_handler *find_xattr_handler_prefix(const char
1040 								*prefix)
1041 {
1042 	struct reiserfs_xattr_handler *xah = NULL;
1043 	struct list_head *p;
1044 
1045 	read_lock(&handler_lock);
1046 	list_for_each(p, &xattr_handlers) {
1047 		xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1048 		if (strncmp(xah->prefix, prefix, strlen(xah->prefix)) == 0)
1049 			break;
1050 		xah = NULL;
1051 	}
1052 
1053 	read_unlock(&handler_lock);
1054 	return xah;
1055 }
1056 
1057 static void __unregister_handlers(void)
1058 {
1059 	struct reiserfs_xattr_handler *xah;
1060 	struct list_head *p, *tmp;
1061 
1062 	list_for_each_safe(p, tmp, &xattr_handlers) {
1063 		xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1064 		if (xah->exit)
1065 			xah->exit();
1066 
1067 		list_del_init(p);
1068 	}
1069 	INIT_LIST_HEAD(&xattr_handlers);
1070 }
1071 
1072 int __init reiserfs_xattr_register_handlers(void)
1073 {
1074 	int err = 0;
1075 	struct reiserfs_xattr_handler *xah;
1076 	struct list_head *p;
1077 
1078 	write_lock(&handler_lock);
1079 
1080 	/* If we're already initialized, nothing to do */
1081 	if (!list_empty(&xattr_handlers)) {
1082 		write_unlock(&handler_lock);
1083 		return 0;
1084 	}
1085 
1086 	/* Add the handlers */
1087 	list_add_tail(&user_handler.handlers, &xattr_handlers);
1088 	list_add_tail(&trusted_handler.handlers, &xattr_handlers);
1089 #ifdef CONFIG_REISERFS_FS_SECURITY
1090 	list_add_tail(&security_handler.handlers, &xattr_handlers);
1091 #endif
1092 #ifdef CONFIG_REISERFS_FS_POSIX_ACL
1093 	list_add_tail(&posix_acl_access_handler.handlers, &xattr_handlers);
1094 	list_add_tail(&posix_acl_default_handler.handlers, &xattr_handlers);
1095 #endif
1096 
1097 	/* Run initializers, if available */
1098 	list_for_each(p, &xattr_handlers) {
1099 		xah = list_entry(p, struct reiserfs_xattr_handler, handlers);
1100 		if (xah->init) {
1101 			err = xah->init();
1102 			if (err) {
1103 				list_del_init(p);
1104 				break;
1105 			}
1106 		}
1107 	}
1108 
1109 	/* Clean up other handlers, if any failed */
1110 	if (err)
1111 		__unregister_handlers();
1112 
1113 	write_unlock(&handler_lock);
1114 	return err;
1115 }
1116 
1117 void reiserfs_xattr_unregister_handlers(void)
1118 {
1119 	write_lock(&handler_lock);
1120 	__unregister_handlers();
1121 	write_unlock(&handler_lock);
1122 }
1123 
1124 /* This will catch lookups from the fs root to .reiserfs_priv */
1125 static int
1126 xattr_lookup_poison(struct dentry *dentry, struct qstr *q1, struct qstr *name)
1127 {
1128 	struct dentry *priv_root = REISERFS_SB(dentry->d_sb)->priv_root;
1129 	if (name->len == priv_root->d_name.len &&
1130 	    name->hash == priv_root->d_name.hash &&
1131 	    !memcmp(name->name, priv_root->d_name.name, name->len)) {
1132 		return -ENOENT;
1133 	} else if (q1->len == name->len &&
1134 		   !memcmp(q1->name, name->name, name->len))
1135 		return 0;
1136 	return 1;
1137 }
1138 
1139 static struct dentry_operations xattr_lookup_poison_ops = {
1140 	.d_compare = xattr_lookup_poison,
1141 };
1142 
1143 /* We need to take a copy of the mount flags since things like
1144  * MS_RDONLY don't get set until *after* we're called.
1145  * mount_flags != mount_options */
1146 int reiserfs_xattr_init(struct super_block *s, int mount_flags)
1147 {
1148 	int err = 0;
1149 
1150 	/* We need generation numbers to ensure that the oid mapping is correct
1151 	 * v3.5 filesystems don't have them. */
1152 	if (!old_format_only(s)) {
1153 		set_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1154 	} else if (reiserfs_xattrs_optional(s)) {
1155 		/* Old format filesystem, but optional xattrs have been enabled
1156 		 * at mount time. Error out. */
1157 		reiserfs_warning(s, "xattrs/ACLs not supported on pre v3.6 "
1158 				 "format filesystem. Failing mount.");
1159 		err = -EOPNOTSUPP;
1160 		goto error;
1161 	} else {
1162 		/* Old format filesystem, but no optional xattrs have been enabled. This
1163 		 * means we silently disable xattrs on the filesystem. */
1164 		clear_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1165 	}
1166 
1167 	/* If we don't have the privroot located yet - go find it */
1168 	if (reiserfs_xattrs(s) && !REISERFS_SB(s)->priv_root) {
1169 		struct dentry *dentry;
1170 		dentry = lookup_one_len(PRIVROOT_NAME, s->s_root,
1171 					strlen(PRIVROOT_NAME));
1172 		if (!IS_ERR(dentry)) {
1173 			if (!(mount_flags & MS_RDONLY) && !dentry->d_inode) {
1174 				struct inode *inode = dentry->d_parent->d_inode;
1175 				mutex_lock_nested(&inode->i_mutex,
1176 						  I_MUTEX_XATTR);
1177 				err = inode->i_op->mkdir(inode, dentry, 0700);
1178 				mutex_unlock(&inode->i_mutex);
1179 				if (err) {
1180 					dput(dentry);
1181 					dentry = NULL;
1182 				}
1183 
1184 				if (dentry && dentry->d_inode)
1185 					reiserfs_warning(s,
1186 							 "Created %s on %s - reserved for "
1187 							 "xattr storage.",
1188 							 PRIVROOT_NAME,
1189 							 reiserfs_bdevname
1190 							 (inode->i_sb));
1191 			} else if (!dentry->d_inode) {
1192 				dput(dentry);
1193 				dentry = NULL;
1194 			}
1195 		} else
1196 			err = PTR_ERR(dentry);
1197 
1198 		if (!err && dentry) {
1199 			s->s_root->d_op = &xattr_lookup_poison_ops;
1200 			reiserfs_mark_inode_private(dentry->d_inode);
1201 			REISERFS_SB(s)->priv_root = dentry;
1202 		} else if (!(mount_flags & MS_RDONLY)) {	/* xattrs are unavailable */
1203 			/* If we're read-only it just means that the dir hasn't been
1204 			 * created. Not an error -- just no xattrs on the fs. We'll
1205 			 * check again if we go read-write */
1206 			reiserfs_warning(s, "xattrs/ACLs enabled and couldn't "
1207 					 "find/create .reiserfs_priv. Failing mount.");
1208 			err = -EOPNOTSUPP;
1209 		}
1210 	}
1211 
1212       error:
1213 	/* This is only nonzero if there was an error initializing the xattr
1214 	 * directory or if there is a condition where we don't support them. */
1215 	if (err) {
1216 		clear_bit(REISERFS_XATTRS, &(REISERFS_SB(s)->s_mount_opt));
1217 		clear_bit(REISERFS_XATTRS_USER, &(REISERFS_SB(s)->s_mount_opt));
1218 		clear_bit(REISERFS_POSIXACL, &(REISERFS_SB(s)->s_mount_opt));
1219 	}
1220 
1221 	/* The super_block MS_POSIXACL must mirror the (no)acl mount option. */
1222 	s->s_flags = s->s_flags & ~MS_POSIXACL;
1223 	if (reiserfs_posixacl(s))
1224 		s->s_flags |= MS_POSIXACL;
1225 
1226 	return err;
1227 }
1228 
1229 static int reiserfs_check_acl(struct inode *inode, int mask)
1230 {
1231 	struct posix_acl *acl;
1232 	int error = -EAGAIN; /* do regular unix permission checks by default */
1233 
1234 	reiserfs_read_lock_xattr_i(inode);
1235 	reiserfs_read_lock_xattrs(inode->i_sb);
1236 
1237 	acl = reiserfs_get_acl(inode, ACL_TYPE_ACCESS);
1238 
1239 	reiserfs_read_unlock_xattrs(inode->i_sb);
1240 	reiserfs_read_unlock_xattr_i(inode);
1241 
1242 	if (acl) {
1243 		if (!IS_ERR(acl)) {
1244 			error = posix_acl_permission(inode, acl, mask);
1245 			posix_acl_release(acl);
1246 		} else if (PTR_ERR(acl) != -ENODATA)
1247 			error = PTR_ERR(acl);
1248 	}
1249 
1250 	return error;
1251 }
1252 
1253 int reiserfs_permission(struct inode *inode, int mask, struct nameidata *nd)
1254 {
1255 	/*
1256 	 * We don't do permission checks on the internal objects.
1257 	 * Permissions are determined by the "owning" object.
1258 	 */
1259 	if (is_reiserfs_priv_object(inode))
1260 		return 0;
1261 
1262 	/*
1263 	 * Stat data v1 doesn't support ACLs.
1264 	 */
1265 	if (get_inode_sd_version(inode) == STAT_DATA_V1)
1266 		return generic_permission(inode, mask, NULL);
1267 	else
1268 		return generic_permission(inode, mask, reiserfs_check_acl);
1269 }
1270