~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/reiserfs/xattr.c

Version: ~ [ linux-5.4.2 ] ~ [ linux-5.3.15 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.88 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.158 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.206 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.206 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.78 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp