Line data    Source code

       1             : /* SPDX-License-Identifier: GPL-2.0 */
       2             : /*
       3             :   File: linux/xattr.h
       4             : 
       5             :   Extended attributes handling.
       6             : 
       7             :   Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
       8             :   Copyright (c) 2001-2002 Silicon Graphics, Inc.  All Rights Reserved.
       9             :   Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
      10             : */
      11             : #ifndef _LINUX_XATTR_H
      12             : #define _LINUX_XATTR_H
      13             : 
      14             : 
      15             : #include <linux/slab.h>
      16             : #include <linux/types.h>
      17             : #include <linux/spinlock.h>
      18             : #include <linux/mm.h>
      19             : #include <linux/user_namespace.h>
      20             : #include <uapi/linux/xattr.h>
      21             : 
      22             : struct inode;
      23             : struct dentry;
      24             : 
      25             : /*
      26             :  * struct xattr_handler: When @name is set, match attributes with exactly that
      27             :  * name.  When @prefix is set instead, match attributes with that prefix and
      28             :  * with a non-empty suffix.
      29             :  */
      30             : struct xattr_handler {
      31             :         const char *name;
      32             :         const char *prefix;
      33             :         int flags;      /* fs private flags */
      34             :         bool (*list)(struct dentry *dentry);
      35             :         int (*get)(const struct xattr_handler *, struct dentry *dentry,
      36             :                    struct inode *inode, const char *name, void *buffer,
      37             :                    size_t size);
      38             :         int (*set)(const struct xattr_handler *,
      39             :                    struct user_namespace *mnt_userns, struct dentry *dentry,
      40             :                    struct inode *inode, const char *name, const void *buffer,
      41             :                    size_t size, int flags);
      42             : };
      43             : 
      44             : const char *xattr_full_name(const struct xattr_handler *, const char *);
      45             : 
      46             : struct xattr {
      47             :         const char *name;
      48             :         void *value;
      49             :         size_t value_len;
      50             : };
      51             : 
      52             : ssize_t __vfs_getxattr(struct dentry *, struct inode *, const char *, void *, size_t);
      53             : ssize_t vfs_getxattr(struct user_namespace *, struct dentry *, const char *,
      54             :                      void *, size_t);
      55             : ssize_t vfs_listxattr(struct dentry *d, char *list, size_t size);
      56             : int __vfs_setxattr(struct user_namespace *, struct dentry *, struct inode *,
      57             :                    const char *, const void *, size_t, int);
      58             : int __vfs_setxattr_noperm(struct user_namespace *, struct dentry *,
      59             :                           const char *, const void *, size_t, int);
      60             : int __vfs_setxattr_locked(struct user_namespace *, struct dentry *,
      61             :                           const char *, const void *, size_t, int,
      62             :                           struct inode **);
      63             : int vfs_setxattr(struct user_namespace *, struct dentry *, const char *,
      64             :                  const void *, size_t, int);
      65             : int __vfs_removexattr(struct user_namespace *, struct dentry *, const char *);
      66             : int __vfs_removexattr_locked(struct user_namespace *, struct dentry *,
      67             :                              const char *, struct inode **);
      68             : int vfs_removexattr(struct user_namespace *, struct dentry *, const char *);
      69             : 
      70             : ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
      71             : ssize_t vfs_getxattr_alloc(struct user_namespace *mnt_userns,
      72             :                            struct dentry *dentry, const char *name,
      73             :                            char **xattr_value, size_t size, gfp_t flags);
      74             : 
      75             : int xattr_supported_namespace(struct inode *inode, const char *prefix);
      76             : 
      77        5321 : static inline const char *xattr_prefix(const struct xattr_handler *handler)
      78             : {
      79        5321 :         return handler->prefix ?: handler->name;
      80             : }
      81             : 
      82             : struct simple_xattrs {
      83             :         struct list_head head;
      84             :         spinlock_t lock;
      85             : };
      86             : 
      87             : struct simple_xattr {
      88             :         struct list_head list;
      89             :         char *name;
      90             :         size_t size;
      91             :         char value[];
      92             : };
      93             : 
      94             : /*
      95             :  * initialize the simple_xattrs structure
      96             :  */
      97        1798 : static inline void simple_xattrs_init(struct simple_xattrs *xattrs)
      98             : {
      99        1798 :         INIT_LIST_HEAD(&xattrs->head);
     100        1798 :         spin_lock_init(&xattrs->lock);
     101        1798 : }
     102             : 
     103             : /*
     104             :  * free all the xattrs
     105             :  */
     106        1189 : static inline void simple_xattrs_free(struct simple_xattrs *xattrs)
     107             : {
     108        1189 :         struct simple_xattr *xattr, *node;
     109             : 
     110        1226 :         list_for_each_entry_safe(xattr, node, &xattrs->head, list) {
     111          37 :                 kfree(xattr->name);
     112          37 :                 kvfree(xattr);
     113             :         }
     114        1189 : }
     115             : 
     116             : struct simple_xattr *simple_xattr_alloc(const void *value, size_t size);
     117             : int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
     118             :                      void *buffer, size_t size);
     119             : int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
     120             :                      const void *value, size_t size, int flags,
     121             :                      ssize_t *removed_size);
     122             : ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs, char *buffer,
     123             :                           size_t size);
     124             : void simple_xattr_list_add(struct simple_xattrs *xattrs,
     125             :                            struct simple_xattr *new_xattr);
     126             : 
     127             : #endif  /* _LINUX_XATTR_H */