fs/xfs/xfs_xattr.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2008 Christoph Hellwig.
   4  * Portions Copyright (C) 2000-2008 Silicon Graphics, Inc.
   5  */
   6
   7 #include "xfs.h"
   8 #include "xfs_shared.h"
   9 #include "xfs_format.h"
  10 #include "xfs_log_format.h"
  11 #include "xfs_da_format.h"
  12 #include "xfs_inode.h"
  13 #include "xfs_attr.h"
  14
  15 #include <linux/posix_acl_xattr.h>
  16 #include <linux/xattr.h>
  17
  18
  19 static int
  20 xfs_xattr_get(const struct xattr_handler *handler, struct dentry *unused,
  21                 struct inode *inode, const char *name, void *value, size_t size)
  22 {
  23         int xflags = handler->flags;
  24         struct xfs_inode *ip = XFS_I(inode);
  25         int error, asize = size;
  26
  27         /* Convert Linux syscall to XFS internal ATTR flags */
  28         if (!size) {
  29                 xflags |= ATTR_KERNOVAL;
  30                 value = NULL;
  31         }
  32
  33         error = xfs_attr_get(ip, name, (unsigned char **)&value, &asize, xflags);
  34         if (error)
  35                 return error;
  36         return asize;
  37 }
  38
  39 void
  40 xfs_forget_acl(
  41         struct inode            *inode,
  42         const char              *name,
  43         int                     xflags)
  44 {
  45         /*
  46          * Invalidate any cached ACLs if the user has bypassed the ACL
  47          * interface. We don't validate the content whatsoever so it is caller
  48          * responsibility to provide data in valid format and ensure i_mode is
  49          * consistent.
  50          */
  51         if (xflags & ATTR_ROOT) {
  52 #ifdef CONFIG_XFS_POSIX_ACL
  53                 if (!strcmp(name, SGI_ACL_FILE))
  54                         forget_cached_acl(inode, ACL_TYPE_ACCESS);
  55                 else if (!strcmp(name, SGI_ACL_DEFAULT))
  56                         forget_cached_acl(inode, ACL_TYPE_DEFAULT);
  57 #endif
  58         }
  59 }
  60
  61 static int
  62 xfs_xattr_set(const struct xattr_handler *handler, struct dentry *unused,
  63                 struct inode *inode, const char *name, const void *value,
  64                 size_t size, int flags)
  65 {
  66         int                     xflags = handler->flags;
  67         struct xfs_inode        *ip = XFS_I(inode);
  68         int                     error;
  69
  70         /* Convert Linux syscall to XFS internal ATTR flags */
  71         if (flags & XATTR_CREATE)
  72                 xflags |= ATTR_CREATE;
  73         if (flags & XATTR_REPLACE)
  74                 xflags |= ATTR_REPLACE;
  75
  76         if (!value)
  77                 return xfs_attr_remove(ip, (unsigned char *)name, xflags);
  78         error = xfs_attr_set(ip, (unsigned char *)name,
  79                                 (void *)value, size, xflags);
  80         if (!error)
  81                 xfs_forget_acl(inode, name, xflags);
  82
  83         return error;
  84 }
  85
  86 static const struct xattr_handler xfs_xattr_user_handler = {
  87         .prefix = XATTR_USER_PREFIX,
  88         .flags  = 0, /* no flags implies user namespace */
  89         .get    = xfs_xattr_get,
  90         .set    = xfs_xattr_set,
  91 };
  92
  93 static const struct xattr_handler xfs_xattr_trusted_handler = {
  94         .prefix = XATTR_TRUSTED_PREFIX,
  95         .flags  = ATTR_ROOT,
  96         .get    = xfs_xattr_get,
  97         .set    = xfs_xattr_set,
  98 };
  99
 100 static const struct xattr_handler xfs_xattr_security_handler = {
 101         .prefix = XATTR_SECURITY_PREFIX,
 102         .flags  = ATTR_SECURE,
 103         .get    = xfs_xattr_get,
 104         .set    = xfs_xattr_set,
 105 };
 106
 107 const struct xattr_handler *xfs_xattr_handlers[] = {
 108         &xfs_xattr_user_handler,
 109         &xfs_xattr_trusted_handler,
 110         &xfs_xattr_security_handler,
 111 #ifdef CONFIG_XFS_POSIX_ACL
 112         &posix_acl_access_xattr_handler,
 113         &posix_acl_default_xattr_handler,
 114 #endif
 115         NULL
 116 };
 117
 118 static void
 119 __xfs_xattr_put_listent(
 120         struct xfs_attr_list_context *context,
 121         char *prefix,
 122         int prefix_len,
 123         unsigned char *name,
 124         int namelen)
 125 {
 126         char *offset;
 127         int arraytop;
 128
 129         if (context->count < 0 || context->seen_enough)
 130                 return;
 131
 132         if (!context->alist)
 133                 goto compute_size;
 134
 135         arraytop = context->count + prefix_len + namelen + 1;
 136         if (arraytop > context->firstu) {
 137                 context->count = -1;    /* insufficient space */
 138                 context->seen_enough = 1;
 139                 return;
 140         }
 141         offset = (char *)context->alist + context->count;
 142         strncpy(offset, prefix, prefix_len);
 143         offset += prefix_len;
 144         strncpy(offset, (char *)name, namelen);                 /* real name */
 145         offset += namelen;
 146         *offset = '\0';
 147
 148 compute_size:
 149         context->count += prefix_len + namelen + 1;
 150         return;
 151 }
 152
 153 static void
 154 xfs_xattr_put_listent(
 155         struct xfs_attr_list_context *context,
 156         int             flags,
 157         unsigned char   *name,
 158         int             namelen,
 159         int             valuelen)
 160 {
 161         char *prefix;
 162         int prefix_len;
 163
 164         ASSERT(context->count >= 0);
 165
 166         if (flags & XFS_ATTR_ROOT) {
 167 #ifdef CONFIG_XFS_POSIX_ACL
 168                 if (namelen == SGI_ACL_FILE_SIZE &&
 169                     strncmp(name, SGI_ACL_FILE,
 170                             SGI_ACL_FILE_SIZE) == 0) {
 171                         __xfs_xattr_put_listent(
 172                                         context, XATTR_SYSTEM_PREFIX,
 173                                         XATTR_SYSTEM_PREFIX_LEN,
 174                                         XATTR_POSIX_ACL_ACCESS,
 175                                         strlen(XATTR_POSIX_ACL_ACCESS));
 176                 } else if (namelen == SGI_ACL_DEFAULT_SIZE &&
 177                          strncmp(name, SGI_ACL_DEFAULT,
 178                                  SGI_ACL_DEFAULT_SIZE) == 0) {
 179                         __xfs_xattr_put_listent(
 180                                         context, XATTR_SYSTEM_PREFIX,
 181                                         XATTR_SYSTEM_PREFIX_LEN,
 182                                         XATTR_POSIX_ACL_DEFAULT,
 183                                         strlen(XATTR_POSIX_ACL_DEFAULT));
 184                 }
 185 #endif
 186
 187                 /*
 188                  * Only show root namespace entries if we are actually allowed to
 189                  * see them.
 190                  */
 191                 if (!capable(CAP_SYS_ADMIN))
 192                         return;
 193
 194                 prefix = XATTR_TRUSTED_PREFIX;
 195                 prefix_len = XATTR_TRUSTED_PREFIX_LEN;
 196         } else if (flags & XFS_ATTR_SECURE) {
 197                 prefix = XATTR_SECURITY_PREFIX;
 198                 prefix_len = XATTR_SECURITY_PREFIX_LEN;
 199         } else {
 200                 prefix = XATTR_USER_PREFIX;
 201                 prefix_len = XATTR_USER_PREFIX_LEN;
 202         }
 203
 204         __xfs_xattr_put_listent(context, prefix, prefix_len, name,
 205                                 namelen);
 206         return;
 207 }
 208
 209 ssize_t
 210 xfs_vn_listxattr(
 211         struct dentry   *dentry,
 212         char            *data,
 213         size_t          size)
 214 {
 215         struct xfs_attr_list_context context;
 216         struct attrlist_cursor_kern cursor = { 0 };
 217         struct inode    *inode = d_inode(dentry);
 218         int             error;
 219
 220         /*
 221          * First read the regular on-disk attributes.
 222          */
 223         memset(&context, 0, sizeof(context));
 224         context.dp = XFS_I(inode);
 225         context.cursor = &cursor;
 226         context.resynch = 1;
 227         context.alist = size ? data : NULL;
 228         context.bufsize = size;
 229         context.firstu = context.bufsize;
 230         context.put_listent = xfs_xattr_put_listent;
 231
 232         error = xfs_attr_list_int(&context);
 233         if (error)
 234                 return error;
 235         if (context.count < 0)
 236                 return -ERANGE;
 237
 238         return context.count;
 239 }