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           0 : static inline bool is_posix_acl_xattr(const char *name)
      26             : {
      27           0 :         return (strcmp(name, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
      28           0 :                (strcmp(name, XATTR_NAME_POSIX_ACL_DEFAULT) == 0);
      29             : }
      30             : 
      31             : /*
      32             :  * struct xattr_handler: When @name is set, match attributes with exactly that
      33             :  * name.  When @prefix is set instead, match attributes with that prefix and
      34             :  * with a non-empty suffix.
      35             :  */
      36             : struct xattr_handler {
      37             :         const char *name;
      38             :         const char *prefix;
      39             :         int flags;      /* fs private flags */
      40             :         bool (*list)(struct dentry *dentry);
      41             :         int (*get)(const struct xattr_handler *, struct dentry *dentry,
      42             :                    struct inode *inode, const char *name, void *buffer,
      43             :                    size_t size);
      44             :         int (*set)(const struct xattr_handler *,
      45             :                    struct mnt_idmap *idmap, struct dentry *dentry,
      46             :                    struct inode *inode, const char *name, const void *buffer,
      47             :                    size_t size, int flags);
      48             : };
      49             : 
      50             : /**
      51             :  * xattr_handler_can_list - check whether xattr can be listed
      52             :  * @handler: handler for this type of xattr
      53             :  * @dentry: dentry whose inode xattr to list
      54             :  *
      55             :  * Determine whether the xattr associated with @dentry can be listed given
      56             :  * @handler.
      57             :  *
      58             :  * Return: true if xattr can be listed, false if not.
      59             :  */
      60             : static inline bool xattr_handler_can_list(const struct xattr_handler *handler,
      61             :                                           struct dentry *dentry)
      62             : {
      63             :         return handler && (!handler->list || handler->list(dentry));
      64             : }
      65             : 
      66             : const char *xattr_full_name(const struct xattr_handler *, const char *);
      67             : 
      68             : struct xattr {
      69             :         const char *name;
      70             :         void *value;
      71             :         size_t value_len;
      72             : };
      73             : 
      74             : ssize_t __vfs_getxattr(struct dentry *, struct inode *, const char *, void *, size_t);
      75             : ssize_t vfs_getxattr(struct mnt_idmap *, struct dentry *, const char *,
      76             :                      void *, size_t);
      77             : ssize_t vfs_listxattr(struct dentry *d, char *list, size_t size);
      78             : int __vfs_setxattr(struct mnt_idmap *, struct dentry *, struct inode *,
      79             :                    const char *, const void *, size_t, int);
      80             : int __vfs_setxattr_noperm(struct mnt_idmap *, struct dentry *,
      81             :                           const char *, const void *, size_t, int);
      82             : int __vfs_setxattr_locked(struct mnt_idmap *, struct dentry *,
      83             :                           const char *, const void *, size_t, int,
      84             :                           struct inode **);
      85             : int vfs_setxattr(struct mnt_idmap *, struct dentry *, const char *,
      86             :                  const void *, size_t, int);
      87             : int __vfs_removexattr(struct mnt_idmap *, struct dentry *, const char *);
      88             : int __vfs_removexattr_locked(struct mnt_idmap *, struct dentry *,
      89             :                              const char *, struct inode **);
      90             : int vfs_removexattr(struct mnt_idmap *, struct dentry *, const char *);
      91             : 
      92             : ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
      93             : int vfs_getxattr_alloc(struct mnt_idmap *idmap,
      94             :                        struct dentry *dentry, const char *name,
      95             :                        char **xattr_value, size_t size, gfp_t flags);
      96             : 
      97             : int xattr_supports_user_prefix(struct inode *inode);
      98             : 
      99             : static inline const char *xattr_prefix(const struct xattr_handler *handler)
     100             : {
     101           0 :         return handler->prefix ?: handler->name;
     102             : }
     103             : 
     104             : struct simple_xattrs {
     105             :         struct rb_root rb_root;
     106             :         rwlock_t lock;
     107             : };
     108             : 
     109             : struct simple_xattr {
     110             :         struct rb_node rb_node;
     111             :         char *name;
     112             :         size_t size;
     113             :         char value[];
     114             : };
     115             : 
     116             : void simple_xattrs_init(struct simple_xattrs *xattrs);
     117             : void simple_xattrs_free(struct simple_xattrs *xattrs);
     118             : struct simple_xattr *simple_xattr_alloc(const void *value, size_t size);
     119             : int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
     120             :                      void *buffer, size_t size);
     121             : int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
     122             :                      const void *value, size_t size, int flags,
     123             :                      ssize_t *removed_size);
     124             : ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
     125             :                           char *buffer, size_t size);
     126             : void simple_xattr_add(struct simple_xattrs *xattrs,
     127             :                       struct simple_xattr *new_xattr);
     128             : int xattr_list_one(char **buffer, ssize_t *remaining_size, const char *name);
     129             : 
     130             : #endif  /* _LINUX_XATTR_H */