LCOV - code coverage report
Current view: top level - fs - xattr.c (source / functions) Hit Total Coverage
Test: Real Lines: 219 380 57.6 %
Date: 2020-10-17 15:46:16 Functions: 6 46 13.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :   File: fs/xattr.c
       4                 :            : 
       5                 :            :   Extended attribute handling.
       6                 :            : 
       7                 :            :   Copyright (C) 2001 by Andreas Gruenbacher <a.gruenbacher@computer.org>
       8                 :            :   Copyright (C) 2001 SGI - Silicon Graphics, Inc <linux-xfs@oss.sgi.com>
       9                 :            :   Copyright (c) 2004 Red Hat, Inc., James Morris <jmorris@redhat.com>
      10                 :            :  */
      11                 :            : #include <linux/fs.h>
      12                 :            : #include <linux/slab.h>
      13                 :            : #include <linux/file.h>
      14                 :            : #include <linux/xattr.h>
      15                 :            : #include <linux/mount.h>
      16                 :            : #include <linux/namei.h>
      17                 :            : #include <linux/security.h>
      18                 :            : #include <linux/evm.h>
      19                 :            : #include <linux/syscalls.h>
      20                 :            : #include <linux/export.h>
      21                 :            : #include <linux/fsnotify.h>
      22                 :            : #include <linux/audit.h>
      23                 :            : #include <linux/vmalloc.h>
      24                 :            : #include <linux/posix_acl_xattr.h>
      25                 :            : 
      26                 :            : #include <linux/uaccess.h>
      27                 :            : 
      28                 :            : static const char *
      29                 :            : strcmp_prefix(const char *a, const char *a_prefix)
      30                 :            : {
      31                 :          3 :         while (*a_prefix && *a == *a_prefix) {
      32                 :          3 :                 a++;
      33                 :          3 :                 a_prefix++;
      34                 :            :         }
      35                 :          3 :         return *a_prefix ? NULL : a;
      36                 :            : }
      37                 :            : 
      38                 :            : /*
      39                 :            :  * In order to implement different sets of xattr operations for each xattr
      40                 :            :  * prefix, a filesystem should create a null-terminated array of struct
      41                 :            :  * xattr_handler (one for each prefix) and hang a pointer to it off of the
      42                 :            :  * s_xattr field of the superblock.
      43                 :            :  */
      44                 :            : #define for_each_xattr_handler(handlers, handler)               \
      45                 :            :         if (handlers)                                           \
      46                 :            :                 for ((handler) = *(handlers)++;                 \
      47                 :            :                         (handler) != NULL;                      \
      48                 :            :                         (handler) = *(handlers)++)
      49                 :            : 
      50                 :            : /*
      51                 :            :  * Find the xattr_handler with the matching prefix.
      52                 :            :  */
      53                 :            : static const struct xattr_handler *
      54                 :          3 : xattr_resolve_name(struct inode *inode, const char **name)
      55                 :            : {
      56                 :          3 :         const struct xattr_handler **handlers = inode->i_sb->s_xattr;
      57                 :            :         const struct xattr_handler *handler;
      58                 :            : 
      59                 :          3 :         if (!(inode->i_opflags & IOP_XATTR)) {
      60                 :          3 :                 if (unlikely(is_bad_inode(inode)))
      61                 :            :                         return ERR_PTR(-EIO);
      62                 :          3 :                 return ERR_PTR(-EOPNOTSUPP);
      63                 :            :         }
      64                 :          3 :         for_each_xattr_handler(handlers, handler) {
      65                 :            :                 const char *n;
      66                 :            : 
      67                 :          3 :                 n = strcmp_prefix(*name, xattr_prefix(handler));
      68                 :          3 :                 if (n) {
      69                 :          3 :                         if (!handler->prefix ^ !*n) {
      70                 :          2 :                                 if (*n)
      71                 :          0 :                                         continue;
      72                 :            :                                 return ERR_PTR(-EINVAL);
      73                 :            :                         }
      74                 :          3 :                         *name = n;
      75                 :          3 :                         return handler;
      76                 :            :                 }
      77                 :            :         }
      78                 :            :         return ERR_PTR(-EOPNOTSUPP);
      79                 :            : }
      80                 :            : 
      81                 :            : /*
      82                 :            :  * Check permissions for extended attribute access.  This is a bit complicated
      83                 :            :  * because different namespaces have very different rules.
      84                 :            :  */
      85                 :            : static int
      86                 :          3 : xattr_permission(struct inode *inode, const char *name, int mask)
      87                 :            : {
      88                 :            :         /*
      89                 :            :          * We can never set or remove an extended attribute on a read-only
      90                 :            :          * filesystem  or on an immutable / append-only inode.
      91                 :            :          */
      92                 :          3 :         if (mask & MAY_WRITE) {
      93                 :          3 :                 if (IS_IMMUTABLE(inode) || IS_APPEND(inode))
      94                 :            :                         return -EPERM;
      95                 :            :                 /*
      96                 :            :                  * Updating an xattr will likely cause i_uid and i_gid
      97                 :            :                  * to be writen back improperly if their true value is
      98                 :            :                  * unknown to the vfs.
      99                 :            :                  */
     100                 :          3 :                 if (HAS_UNMAPPED_ID(inode))
     101                 :            :                         return -EPERM;
     102                 :            :         }
     103                 :            : 
     104                 :            :         /*
     105                 :            :          * No restriction for security.* and system.* from the VFS.  Decision
     106                 :            :          * on these is left to the underlying filesystem / security module.
     107                 :            :          */
     108                 :          3 :         if (!strncmp(name, XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) ||
     109                 :          3 :             !strncmp(name, XATTR_SYSTEM_PREFIX, XATTR_SYSTEM_PREFIX_LEN))
     110                 :            :                 return 0;
     111                 :            : 
     112                 :            :         /*
     113                 :            :          * The trusted.* namespace can only be accessed by privileged users.
     114                 :            :          */
     115                 :          3 :         if (!strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN)) {
     116                 :          3 :                 if (!capable(CAP_SYS_ADMIN))
     117                 :          0 :                         return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
     118                 :            :                 return 0;
     119                 :            :         }
     120                 :            : 
     121                 :            :         /*
     122                 :            :          * In the user.* namespace, only regular files and directories can have
     123                 :            :          * extended attributes. For sticky directories, only the owner and
     124                 :            :          * privileged users can write attributes.
     125                 :            :          */
     126                 :          3 :         if (!strncmp(name, XATTR_USER_PREFIX, XATTR_USER_PREFIX_LEN)) {
     127                 :          3 :                 if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode))
     128                 :          0 :                         return (mask & MAY_WRITE) ? -EPERM : -ENODATA;
     129                 :          3 :                 if (S_ISDIR(inode->i_mode) && (inode->i_mode & S_ISVTX) &&
     130                 :          0 :                     (mask & MAY_WRITE) && !inode_owner_or_capable(inode))
     131                 :            :                         return -EPERM;
     132                 :            :         }
     133                 :            : 
     134                 :          3 :         return inode_permission(inode, mask);
     135                 :            : }
     136                 :            : 
     137                 :            : int
     138                 :          3 : __vfs_setxattr(struct dentry *dentry, struct inode *inode, const char *name,
     139                 :            :                const void *value, size_t size, int flags)
     140                 :            : {
     141                 :            :         const struct xattr_handler *handler;
     142                 :            : 
     143                 :          3 :         handler = xattr_resolve_name(inode, &name);
     144                 :          3 :         if (IS_ERR(handler))
     145                 :          3 :                 return PTR_ERR(handler);
     146                 :          3 :         if (!handler->set)
     147                 :            :                 return -EOPNOTSUPP;
     148                 :          3 :         if (size == 0)
     149                 :            :                 value = "";  /* empty EA, do not remove */
     150                 :          3 :         return handler->set(handler, dentry, inode, name, value, size, flags);
     151                 :            : }
     152                 :            : EXPORT_SYMBOL(__vfs_setxattr);
     153                 :            : 
     154                 :            : /**
     155                 :            :  *  __vfs_setxattr_noperm - perform setxattr operation without performing
     156                 :            :  *  permission checks.
     157                 :            :  *
     158                 :            :  *  @dentry - object to perform setxattr on
     159                 :            :  *  @name - xattr name to set
     160                 :            :  *  @value - value to set @name to
     161                 :            :  *  @size - size of @value
     162                 :            :  *  @flags - flags to pass into filesystem operations
     163                 :            :  *
     164                 :            :  *  returns the result of the internal setxattr or setsecurity operations.
     165                 :            :  *
     166                 :            :  *  This function requires the caller to lock the inode's i_mutex before it
     167                 :            :  *  is executed. It also assumes that the caller will make the appropriate
     168                 :            :  *  permission checks.
     169                 :            :  */
     170                 :          3 : int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,
     171                 :            :                 const void *value, size_t size, int flags)
     172                 :            : {
     173                 :          3 :         struct inode *inode = dentry->d_inode;
     174                 :            :         int error = -EAGAIN;
     175                 :          3 :         int issec = !strncmp(name, XATTR_SECURITY_PREFIX,
     176                 :            :                                    XATTR_SECURITY_PREFIX_LEN);
     177                 :            : 
     178                 :          3 :         if (issec)
     179                 :          0 :                 inode->i_flags &= ~S_NOSEC;
     180                 :          3 :         if (inode->i_opflags & IOP_XATTR) {
     181                 :          3 :                 error = __vfs_setxattr(dentry, inode, name, value, size, flags);
     182                 :          3 :                 if (!error) {
     183                 :          3 :                         fsnotify_xattr(dentry);
     184                 :          3 :                         security_inode_post_setxattr(dentry, name, value,
     185                 :            :                                                      size, flags);
     186                 :            :                 }
     187                 :            :         } else {
     188                 :          0 :                 if (unlikely(is_bad_inode(inode)))
     189                 :            :                         return -EIO;
     190                 :            :         }
     191                 :          3 :         if (error == -EAGAIN) {
     192                 :            :                 error = -EOPNOTSUPP;
     193                 :            : 
     194                 :          0 :                 if (issec) {
     195                 :          0 :                         const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
     196                 :            : 
     197                 :          0 :                         error = security_inode_setsecurity(inode, suffix, value,
     198                 :            :                                                            size, flags);
     199                 :          0 :                         if (!error)
     200                 :          0 :                                 fsnotify_xattr(dentry);
     201                 :            :                 }
     202                 :            :         }
     203                 :            : 
     204                 :          3 :         return error;
     205                 :            : }
     206                 :            : 
     207                 :            : /**
     208                 :            :  * __vfs_setxattr_locked: set an extended attribute while holding the inode
     209                 :            :  * lock
     210                 :            :  *
     211                 :            :  *  @dentry - object to perform setxattr on
     212                 :            :  *  @name - xattr name to set
     213                 :            :  *  @value - value to set @name to
     214                 :            :  *  @size - size of @value
     215                 :            :  *  @flags - flags to pass into filesystem operations
     216                 :            :  *  @delegated_inode - on return, will contain an inode pointer that
     217                 :            :  *  a delegation was broken on, NULL if none.
     218                 :            :  */
     219                 :            : int
     220                 :          3 : __vfs_setxattr_locked(struct dentry *dentry, const char *name,
     221                 :            :                 const void *value, size_t size, int flags,
     222                 :            :                 struct inode **delegated_inode)
     223                 :            : {
     224                 :          3 :         struct inode *inode = dentry->d_inode;
     225                 :            :         int error;
     226                 :            : 
     227                 :          3 :         error = xattr_permission(inode, name, MAY_WRITE);
     228                 :          3 :         if (error)
     229                 :            :                 return error;
     230                 :            : 
     231                 :          3 :         error = security_inode_setxattr(dentry, name, value, size, flags);
     232                 :          3 :         if (error)
     233                 :            :                 goto out;
     234                 :            : 
     235                 :          3 :         error = try_break_deleg(inode, delegated_inode);
     236                 :          3 :         if (error)
     237                 :            :                 goto out;
     238                 :            : 
     239                 :          3 :         error = __vfs_setxattr_noperm(dentry, name, value, size, flags);
     240                 :            : 
     241                 :            : out:
     242                 :          3 :         return error;
     243                 :            : }
     244                 :            : EXPORT_SYMBOL_GPL(__vfs_setxattr_locked);
     245                 :            : 
     246                 :            : int
     247                 :          3 : vfs_setxattr(struct dentry *dentry, const char *name, const void *value,
     248                 :            :                 size_t size, int flags)
     249                 :            : {
     250                 :          3 :         struct inode *inode = dentry->d_inode;
     251                 :          3 :         struct inode *delegated_inode = NULL;
     252                 :            :         int error;
     253                 :            : 
     254                 :            : retry_deleg:
     255                 :            :         inode_lock(inode);
     256                 :          3 :         error = __vfs_setxattr_locked(dentry, name, value, size, flags,
     257                 :            :             &delegated_inode);
     258                 :            :         inode_unlock(inode);
     259                 :            : 
     260                 :          3 :         if (delegated_inode) {
     261                 :          0 :                 error = break_deleg_wait(&delegated_inode);
     262                 :          0 :                 if (!error)
     263                 :            :                         goto retry_deleg;
     264                 :            :         }
     265                 :          3 :         return error;
     266                 :            : }
     267                 :            : EXPORT_SYMBOL_GPL(vfs_setxattr);
     268                 :            : 
     269                 :            : static ssize_t
     270                 :          3 : xattr_getsecurity(struct inode *inode, const char *name, void *value,
     271                 :            :                         size_t size)
     272                 :            : {
     273                 :          3 :         void *buffer = NULL;
     274                 :            :         ssize_t len;
     275                 :            : 
     276                 :          3 :         if (!value || !size) {
     277                 :          0 :                 len = security_inode_getsecurity(inode, name, &buffer, false);
     278                 :          0 :                 goto out_noalloc;
     279                 :            :         }
     280                 :            : 
     281                 :          3 :         len = security_inode_getsecurity(inode, name, &buffer, true);
     282                 :          3 :         if (len < 0)
     283                 :            :                 return len;
     284                 :          0 :         if (size < len) {
     285                 :            :                 len = -ERANGE;
     286                 :            :                 goto out;
     287                 :            :         }
     288                 :          0 :         memcpy(value, buffer, len);
     289                 :            : out:
     290                 :          0 :         kfree(buffer);
     291                 :            : out_noalloc:
     292                 :          0 :         return len;
     293                 :            : }
     294                 :            : 
     295                 :            : /*
     296                 :            :  * vfs_getxattr_alloc - allocate memory, if necessary, before calling getxattr
     297                 :            :  *
     298                 :            :  * Allocate memory, if not already allocated, or re-allocate correct size,
     299                 :            :  * before retrieving the extended attribute.
     300                 :            :  *
     301                 :            :  * Returns the result of alloc, if failed, or the getxattr operation.
     302                 :            :  */
     303                 :            : ssize_t
     304                 :          0 : vfs_getxattr_alloc(struct dentry *dentry, const char *name, char **xattr_value,
     305                 :            :                    size_t xattr_size, gfp_t flags)
     306                 :            : {
     307                 :            :         const struct xattr_handler *handler;
     308                 :          0 :         struct inode *inode = dentry->d_inode;
     309                 :          0 :         char *value = *xattr_value;
     310                 :            :         int error;
     311                 :            : 
     312                 :          0 :         error = xattr_permission(inode, name, MAY_READ);
     313                 :          0 :         if (error)
     314                 :            :                 return error;
     315                 :            : 
     316                 :          0 :         handler = xattr_resolve_name(inode, &name);
     317                 :          0 :         if (IS_ERR(handler))
     318                 :          0 :                 return PTR_ERR(handler);
     319                 :          0 :         if (!handler->get)
     320                 :            :                 return -EOPNOTSUPP;
     321                 :          0 :         error = handler->get(handler, dentry, inode, name, NULL, 0);
     322                 :          0 :         if (error < 0)
     323                 :            :                 return error;
     324                 :            : 
     325                 :          0 :         if (!value || (error > xattr_size)) {
     326                 :          0 :                 value = krealloc(*xattr_value, error + 1, flags);
     327                 :          0 :                 if (!value)
     328                 :            :                         return -ENOMEM;
     329                 :          0 :                 memset(value, 0, error + 1);
     330                 :            :         }
     331                 :            : 
     332                 :          0 :         error = handler->get(handler, dentry, inode, name, value, error);
     333                 :          0 :         *xattr_value = value;
     334                 :          0 :         return error;
     335                 :            : }
     336                 :            : 
     337                 :            : ssize_t
     338                 :          3 : __vfs_getxattr(struct dentry *dentry, struct inode *inode, const char *name,
     339                 :            :                void *value, size_t size)
     340                 :            : {
     341                 :            :         const struct xattr_handler *handler;
     342                 :            : 
     343                 :          3 :         handler = xattr_resolve_name(inode, &name);
     344                 :          3 :         if (IS_ERR(handler))
     345                 :          3 :                 return PTR_ERR(handler);
     346                 :          3 :         if (!handler->get)
     347                 :            :                 return -EOPNOTSUPP;
     348                 :          3 :         return handler->get(handler, dentry, inode, name, value, size);
     349                 :            : }
     350                 :            : EXPORT_SYMBOL(__vfs_getxattr);
     351                 :            : 
     352                 :            : ssize_t
     353                 :          3 : vfs_getxattr(struct dentry *dentry, const char *name, void *value, size_t size)
     354                 :            : {
     355                 :          3 :         struct inode *inode = dentry->d_inode;
     356                 :            :         int error;
     357                 :            : 
     358                 :          3 :         error = xattr_permission(inode, name, MAY_READ);
     359                 :          3 :         if (error)
     360                 :            :                 return error;
     361                 :            : 
     362                 :          3 :         error = security_inode_getxattr(dentry, name);
     363                 :          3 :         if (error)
     364                 :            :                 return error;
     365                 :            : 
     366                 :          3 :         if (!strncmp(name, XATTR_SECURITY_PREFIX,
     367                 :            :                                 XATTR_SECURITY_PREFIX_LEN)) {
     368                 :          3 :                 const char *suffix = name + XATTR_SECURITY_PREFIX_LEN;
     369                 :          3 :                 int ret = xattr_getsecurity(inode, suffix, value, size);
     370                 :            :                 /*
     371                 :            :                  * Only overwrite the return value if a security module
     372                 :            :                  * is actually active.
     373                 :            :                  */
     374                 :          3 :                 if (ret == -EOPNOTSUPP)
     375                 :            :                         goto nolsm;
     376                 :            :                 return ret;
     377                 :            :         }
     378                 :            : nolsm:
     379                 :          3 :         return __vfs_getxattr(dentry, inode, name, value, size);
     380                 :            : }
     381                 :            : EXPORT_SYMBOL_GPL(vfs_getxattr);
     382                 :            : 
     383                 :            : ssize_t
     384                 :          0 : vfs_listxattr(struct dentry *dentry, char *list, size_t size)
     385                 :            : {
     386                 :            :         struct inode *inode = d_inode(dentry);
     387                 :            :         ssize_t error;
     388                 :            : 
     389                 :          0 :         error = security_inode_listxattr(dentry);
     390                 :          0 :         if (error)
     391                 :            :                 return error;
     392                 :          0 :         if (inode->i_op->listxattr && (inode->i_opflags & IOP_XATTR)) {
     393                 :          0 :                 error = inode->i_op->listxattr(dentry, list, size);
     394                 :            :         } else {
     395                 :          0 :                 error = security_inode_listsecurity(inode, list, size);
     396                 :          0 :                 if (size && error > size)
     397                 :            :                         error = -ERANGE;
     398                 :            :         }
     399                 :          0 :         return error;
     400                 :            : }
     401                 :            : EXPORT_SYMBOL_GPL(vfs_listxattr);
     402                 :            : 
     403                 :            : int
     404                 :          3 : __vfs_removexattr(struct dentry *dentry, const char *name)
     405                 :            : {
     406                 :            :         struct inode *inode = d_inode(dentry);
     407                 :            :         const struct xattr_handler *handler;
     408                 :            : 
     409                 :          3 :         handler = xattr_resolve_name(inode, &name);
     410                 :          3 :         if (IS_ERR(handler))
     411                 :          0 :                 return PTR_ERR(handler);
     412                 :          3 :         if (!handler->set)
     413                 :            :                 return -EOPNOTSUPP;
     414                 :          3 :         return handler->set(handler, dentry, inode, name, NULL, 0, XATTR_REPLACE);
     415                 :            : }
     416                 :            : EXPORT_SYMBOL(__vfs_removexattr);
     417                 :            : 
     418                 :            : /**
     419                 :            :  * __vfs_removexattr_locked: set an extended attribute while holding the inode
     420                 :            :  * lock
     421                 :            :  *
     422                 :            :  *  @dentry - object to perform setxattr on
     423                 :            :  *  @name - name of xattr to remove
     424                 :            :  *  @delegated_inode - on return, will contain an inode pointer that
     425                 :            :  *  a delegation was broken on, NULL if none.
     426                 :            :  */
     427                 :            : int
     428                 :          3 : __vfs_removexattr_locked(struct dentry *dentry, const char *name,
     429                 :            :                 struct inode **delegated_inode)
     430                 :            : {
     431                 :          3 :         struct inode *inode = dentry->d_inode;
     432                 :            :         int error;
     433                 :            : 
     434                 :          3 :         error = xattr_permission(inode, name, MAY_WRITE);
     435                 :          3 :         if (error)
     436                 :            :                 return error;
     437                 :            : 
     438                 :          3 :         error = security_inode_removexattr(dentry, name);
     439                 :          3 :         if (error)
     440                 :            :                 goto out;
     441                 :            : 
     442                 :          3 :         error = try_break_deleg(inode, delegated_inode);
     443                 :          3 :         if (error)
     444                 :            :                 goto out;
     445                 :            : 
     446                 :          3 :         error = __vfs_removexattr(dentry, name);
     447                 :            : 
     448                 :          3 :         if (!error) {
     449                 :          3 :                 fsnotify_xattr(dentry);
     450                 :            :                 evm_inode_post_removexattr(dentry, name);
     451                 :            :         }
     452                 :            : 
     453                 :            : out:
     454                 :          3 :         return error;
     455                 :            : }
     456                 :            : EXPORT_SYMBOL_GPL(__vfs_removexattr_locked);
     457                 :            : 
     458                 :            : int
     459                 :          3 : vfs_removexattr(struct dentry *dentry, const char *name)
     460                 :            : {
     461                 :          3 :         struct inode *inode = dentry->d_inode;
     462                 :          3 :         struct inode *delegated_inode = NULL;
     463                 :            :         int error;
     464                 :            : 
     465                 :            : retry_deleg:
     466                 :            :         inode_lock(inode);
     467                 :          3 :         error = __vfs_removexattr_locked(dentry, name, &delegated_inode);
     468                 :            :         inode_unlock(inode);
     469                 :            : 
     470                 :          3 :         if (delegated_inode) {
     471                 :          0 :                 error = break_deleg_wait(&delegated_inode);
     472                 :          0 :                 if (!error)
     473                 :            :                         goto retry_deleg;
     474                 :            :         }
     475                 :            : 
     476                 :          3 :         return error;
     477                 :            : }
     478                 :            : EXPORT_SYMBOL_GPL(vfs_removexattr);
     479                 :            : 
     480                 :            : /*
     481                 :            :  * Extended attribute SET operations
     482                 :            :  */
     483                 :            : static long
     484                 :          3 : setxattr(struct dentry *d, const char __user *name, const void __user *value,
     485                 :            :          size_t size, int flags)
     486                 :            : {
     487                 :            :         int error;
     488                 :          3 :         void *kvalue = NULL;
     489                 :            :         char kname[XATTR_NAME_MAX + 1];
     490                 :            : 
     491                 :          3 :         if (flags & ~(XATTR_CREATE|XATTR_REPLACE))
     492                 :            :                 return -EINVAL;
     493                 :            : 
     494                 :          3 :         error = strncpy_from_user(kname, name, sizeof(kname));
     495                 :          3 :         if (error == 0 || error == sizeof(kname))
     496                 :            :                 error = -ERANGE;
     497                 :          3 :         if (error < 0)
     498                 :            :                 return error;
     499                 :            : 
     500                 :          3 :         if (size) {
     501                 :          3 :                 if (size > XATTR_SIZE_MAX)
     502                 :            :                         return -E2BIG;
     503                 :          3 :                 kvalue = kvmalloc(size, GFP_KERNEL);
     504                 :          3 :                 if (!kvalue)
     505                 :            :                         return -ENOMEM;
     506                 :          3 :                 if (copy_from_user(kvalue, value, size)) {
     507                 :            :                         error = -EFAULT;
     508                 :            :                         goto out;
     509                 :            :                 }
     510                 :          3 :                 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
     511                 :          3 :                     (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
     512                 :          3 :                         posix_acl_fix_xattr_from_user(kvalue, size);
     513                 :          3 :                 else if (strcmp(kname, XATTR_NAME_CAPS) == 0) {
     514                 :          0 :                         error = cap_convert_nscap(d, &kvalue, size);
     515                 :          0 :                         if (error < 0)
     516                 :            :                                 goto out;
     517                 :          0 :                         size = error;
     518                 :            :                 }
     519                 :            :         }
     520                 :            : 
     521                 :          3 :         error = vfs_setxattr(d, kname, kvalue, size, flags);
     522                 :            : out:
     523                 :          3 :         kvfree(kvalue);
     524                 :            : 
     525                 :          3 :         return error;
     526                 :            : }
     527                 :            : 
     528                 :          3 : static int path_setxattr(const char __user *pathname,
     529                 :            :                          const char __user *name, const void __user *value,
     530                 :            :                          size_t size, int flags, unsigned int lookup_flags)
     531                 :            : {
     532                 :            :         struct path path;
     533                 :            :         int error;
     534                 :            : retry:
     535                 :            :         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
     536                 :          3 :         if (error)
     537                 :          0 :                 return error;
     538                 :          3 :         error = mnt_want_write(path.mnt);
     539                 :          3 :         if (!error) {
     540                 :          3 :                 error = setxattr(path.dentry, name, value, size, flags);
     541                 :          3 :                 mnt_drop_write(path.mnt);
     542                 :            :         }
     543                 :          3 :         path_put(&path);
     544                 :          3 :         if (retry_estale(error, lookup_flags)) {
     545                 :          0 :                 lookup_flags |= LOOKUP_REVAL;
     546                 :          0 :                 goto retry;
     547                 :            :         }
     548                 :          3 :         return error;
     549                 :            : }
     550                 :            : 
     551                 :          3 : SYSCALL_DEFINE5(setxattr, const char __user *, pathname,
     552                 :            :                 const char __user *, name, const void __user *, value,
     553                 :            :                 size_t, size, int, flags)
     554                 :            : {
     555                 :          3 :         return path_setxattr(pathname, name, value, size, flags, LOOKUP_FOLLOW);
     556                 :            : }
     557                 :            : 
     558                 :          0 : SYSCALL_DEFINE5(lsetxattr, const char __user *, pathname,
     559                 :            :                 const char __user *, name, const void __user *, value,
     560                 :            :                 size_t, size, int, flags)
     561                 :            : {
     562                 :          0 :         return path_setxattr(pathname, name, value, size, flags, 0);
     563                 :            : }
     564                 :            : 
     565                 :          3 : SYSCALL_DEFINE5(fsetxattr, int, fd, const char __user *, name,
     566                 :            :                 const void __user *,value, size_t, size, int, flags)
     567                 :            : {
     568                 :          3 :         struct fd f = fdget(fd);
     569                 :            :         int error = -EBADF;
     570                 :            : 
     571                 :          3 :         if (!f.file)
     572                 :            :                 return error;
     573                 :          3 :         audit_file(f.file);
     574                 :          3 :         error = mnt_want_write_file(f.file);
     575                 :          3 :         if (!error) {
     576                 :          3 :                 error = setxattr(f.file->f_path.dentry, name, value, size, flags);
     577                 :          3 :                 mnt_drop_write_file(f.file);
     578                 :            :         }
     579                 :            :         fdput(f);
     580                 :          3 :         return error;
     581                 :            : }
     582                 :            : 
     583                 :            : /*
     584                 :            :  * Extended attribute GET operations
     585                 :            :  */
     586                 :            : static ssize_t
     587                 :          3 : getxattr(struct dentry *d, const char __user *name, void __user *value,
     588                 :            :          size_t size)
     589                 :            : {
     590                 :            :         ssize_t error;
     591                 :            :         void *kvalue = NULL;
     592                 :            :         char kname[XATTR_NAME_MAX + 1];
     593                 :            : 
     594                 :          3 :         error = strncpy_from_user(kname, name, sizeof(kname));
     595                 :          3 :         if (error == 0 || error == sizeof(kname))
     596                 :            :                 error = -ERANGE;
     597                 :          3 :         if (error < 0)
     598                 :            :                 return error;
     599                 :            : 
     600                 :          3 :         if (size) {
     601                 :          3 :                 if (size > XATTR_SIZE_MAX)
     602                 :            :                         size = XATTR_SIZE_MAX;
     603                 :            :                 kvalue = kvzalloc(size, GFP_KERNEL);
     604                 :          3 :                 if (!kvalue)
     605                 :            :                         return -ENOMEM;
     606                 :            :         }
     607                 :            : 
     608                 :          3 :         error = vfs_getxattr(d, kname, kvalue, size);
     609                 :          3 :         if (error > 0) {
     610                 :          0 :                 if ((strcmp(kname, XATTR_NAME_POSIX_ACL_ACCESS) == 0) ||
     611                 :          0 :                     (strcmp(kname, XATTR_NAME_POSIX_ACL_DEFAULT) == 0))
     612                 :          0 :                         posix_acl_fix_xattr_to_user(kvalue, error);
     613                 :          0 :                 if (size && copy_to_user(value, kvalue, error))
     614                 :            :                         error = -EFAULT;
     615                 :          3 :         } else if (error == -ERANGE && size >= XATTR_SIZE_MAX) {
     616                 :            :                 /* The file system tried to returned a value bigger
     617                 :            :                    than XATTR_SIZE_MAX bytes. Not possible. */
     618                 :            :                 error = -E2BIG;
     619                 :            :         }
     620                 :            : 
     621                 :          3 :         kvfree(kvalue);
     622                 :            : 
     623                 :          3 :         return error;
     624                 :            : }
     625                 :            : 
     626                 :          3 : static ssize_t path_getxattr(const char __user *pathname,
     627                 :            :                              const char __user *name, void __user *value,
     628                 :            :                              size_t size, unsigned int lookup_flags)
     629                 :            : {
     630                 :            :         struct path path;
     631                 :            :         ssize_t error;
     632                 :            : retry:
     633                 :            :         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
     634                 :          3 :         if (error)
     635                 :          0 :                 return error;
     636                 :          3 :         error = getxattr(path.dentry, name, value, size);
     637                 :          3 :         path_put(&path);
     638                 :          3 :         if (retry_estale(error, lookup_flags)) {
     639                 :          0 :                 lookup_flags |= LOOKUP_REVAL;
     640                 :          0 :                 goto retry;
     641                 :            :         }
     642                 :          3 :         return error;
     643                 :            : }
     644                 :            : 
     645                 :          3 : SYSCALL_DEFINE4(getxattr, const char __user *, pathname,
     646                 :            :                 const char __user *, name, void __user *, value, size_t, size)
     647                 :            : {
     648                 :          3 :         return path_getxattr(pathname, name, value, size, LOOKUP_FOLLOW);
     649                 :            : }
     650                 :            : 
     651                 :          3 : SYSCALL_DEFINE4(lgetxattr, const char __user *, pathname,
     652                 :            :                 const char __user *, name, void __user *, value, size_t, size)
     653                 :            : {
     654                 :          3 :         return path_getxattr(pathname, name, value, size, 0);
     655                 :            : }
     656                 :            : 
     657                 :          2 : SYSCALL_DEFINE4(fgetxattr, int, fd, const char __user *, name,
     658                 :            :                 void __user *, value, size_t, size)
     659                 :            : {
     660                 :          2 :         struct fd f = fdget(fd);
     661                 :            :         ssize_t error = -EBADF;
     662                 :            : 
     663                 :          2 :         if (!f.file)
     664                 :            :                 return error;
     665                 :          2 :         audit_file(f.file);
     666                 :          2 :         error = getxattr(f.file->f_path.dentry, name, value, size);
     667                 :            :         fdput(f);
     668                 :          2 :         return error;
     669                 :            : }
     670                 :            : 
     671                 :            : /*
     672                 :            :  * Extended attribute LIST operations
     673                 :            :  */
     674                 :            : static ssize_t
     675                 :          0 : listxattr(struct dentry *d, char __user *list, size_t size)
     676                 :            : {
     677                 :            :         ssize_t error;
     678                 :            :         char *klist = NULL;
     679                 :            : 
     680                 :          0 :         if (size) {
     681                 :          0 :                 if (size > XATTR_LIST_MAX)
     682                 :            :                         size = XATTR_LIST_MAX;
     683                 :            :                 klist = kvmalloc(size, GFP_KERNEL);
     684                 :          0 :                 if (!klist)
     685                 :            :                         return -ENOMEM;
     686                 :            :         }
     687                 :            : 
     688                 :          0 :         error = vfs_listxattr(d, klist, size);
     689                 :          0 :         if (error > 0) {
     690                 :          0 :                 if (size && copy_to_user(list, klist, error))
     691                 :            :                         error = -EFAULT;
     692                 :          0 :         } else if (error == -ERANGE && size >= XATTR_LIST_MAX) {
     693                 :            :                 /* The file system tried to returned a list bigger
     694                 :            :                    than XATTR_LIST_MAX bytes. Not possible. */
     695                 :            :                 error = -E2BIG;
     696                 :            :         }
     697                 :            : 
     698                 :          0 :         kvfree(klist);
     699                 :            : 
     700                 :          0 :         return error;
     701                 :            : }
     702                 :            : 
     703                 :          0 : static ssize_t path_listxattr(const char __user *pathname, char __user *list,
     704                 :            :                               size_t size, unsigned int lookup_flags)
     705                 :            : {
     706                 :            :         struct path path;
     707                 :            :         ssize_t error;
     708                 :            : retry:
     709                 :            :         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
     710                 :          0 :         if (error)
     711                 :          0 :                 return error;
     712                 :          0 :         error = listxattr(path.dentry, list, size);
     713                 :          0 :         path_put(&path);
     714                 :          0 :         if (retry_estale(error, lookup_flags)) {
     715                 :          0 :                 lookup_flags |= LOOKUP_REVAL;
     716                 :          0 :                 goto retry;
     717                 :            :         }
     718                 :          0 :         return error;
     719                 :            : }
     720                 :            : 
     721                 :          0 : SYSCALL_DEFINE3(listxattr, const char __user *, pathname, char __user *, list,
     722                 :            :                 size_t, size)
     723                 :            : {
     724                 :          0 :         return path_listxattr(pathname, list, size, LOOKUP_FOLLOW);
     725                 :            : }
     726                 :            : 
     727                 :          0 : SYSCALL_DEFINE3(llistxattr, const char __user *, pathname, char __user *, list,
     728                 :            :                 size_t, size)
     729                 :            : {
     730                 :          0 :         return path_listxattr(pathname, list, size, 0);
     731                 :            : }
     732                 :            : 
     733                 :          0 : SYSCALL_DEFINE3(flistxattr, int, fd, char __user *, list, size_t, size)
     734                 :            : {
     735                 :          0 :         struct fd f = fdget(fd);
     736                 :            :         ssize_t error = -EBADF;
     737                 :            : 
     738                 :          0 :         if (!f.file)
     739                 :            :                 return error;
     740                 :          0 :         audit_file(f.file);
     741                 :          0 :         error = listxattr(f.file->f_path.dentry, list, size);
     742                 :            :         fdput(f);
     743                 :          0 :         return error;
     744                 :            : }
     745                 :            : 
     746                 :            : /*
     747                 :            :  * Extended attribute REMOVE operations
     748                 :            :  */
     749                 :            : static long
     750                 :          3 : removexattr(struct dentry *d, const char __user *name)
     751                 :            : {
     752                 :            :         int error;
     753                 :            :         char kname[XATTR_NAME_MAX + 1];
     754                 :            : 
     755                 :          3 :         error = strncpy_from_user(kname, name, sizeof(kname));
     756                 :          3 :         if (error == 0 || error == sizeof(kname))
     757                 :            :                 error = -ERANGE;
     758                 :          3 :         if (error < 0)
     759                 :            :                 return error;
     760                 :            : 
     761                 :          3 :         return vfs_removexattr(d, kname);
     762                 :            : }
     763                 :            : 
     764                 :          3 : static int path_removexattr(const char __user *pathname,
     765                 :            :                             const char __user *name, unsigned int lookup_flags)
     766                 :            : {
     767                 :            :         struct path path;
     768                 :            :         int error;
     769                 :            : retry:
     770                 :            :         error = user_path_at(AT_FDCWD, pathname, lookup_flags, &path);
     771                 :          3 :         if (error)
     772                 :          0 :                 return error;
     773                 :          3 :         error = mnt_want_write(path.mnt);
     774                 :          3 :         if (!error) {
     775                 :          3 :                 error = removexattr(path.dentry, name);
     776                 :          3 :                 mnt_drop_write(path.mnt);
     777                 :            :         }
     778                 :          3 :         path_put(&path);
     779                 :          3 :         if (retry_estale(error, lookup_flags)) {
     780                 :          0 :                 lookup_flags |= LOOKUP_REVAL;
     781                 :          0 :                 goto retry;
     782                 :            :         }
     783                 :          3 :         return error;
     784                 :            : }
     785                 :            : 
     786                 :          3 : SYSCALL_DEFINE2(removexattr, const char __user *, pathname,
     787                 :            :                 const char __user *, name)
     788                 :            : {
     789                 :          3 :         return path_removexattr(pathname, name, LOOKUP_FOLLOW);
     790                 :            : }
     791                 :            : 
     792                 :          0 : SYSCALL_DEFINE2(lremovexattr, const char __user *, pathname,
     793                 :            :                 const char __user *, name)
     794                 :            : {
     795                 :          0 :         return path_removexattr(pathname, name, 0);
     796                 :            : }
     797                 :            : 
     798                 :          0 : SYSCALL_DEFINE2(fremovexattr, int, fd, const char __user *, name)
     799                 :            : {
     800                 :          0 :         struct fd f = fdget(fd);
     801                 :            :         int error = -EBADF;
     802                 :            : 
     803                 :          0 :         if (!f.file)
     804                 :            :                 return error;
     805                 :          0 :         audit_file(f.file);
     806                 :          0 :         error = mnt_want_write_file(f.file);
     807                 :          0 :         if (!error) {
     808                 :          0 :                 error = removexattr(f.file->f_path.dentry, name);
     809                 :          0 :                 mnt_drop_write_file(f.file);
     810                 :            :         }
     811                 :            :         fdput(f);
     812                 :          0 :         return error;
     813                 :            : }
     814                 :            : 
     815                 :            : /*
     816                 :            :  * Combine the results of the list() operation from every xattr_handler in the
     817                 :            :  * list.
     818                 :            :  */
     819                 :            : ssize_t
     820                 :          0 : generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
     821                 :            : {
     822                 :          0 :         const struct xattr_handler *handler, **handlers = dentry->d_sb->s_xattr;
     823                 :            :         unsigned int size = 0;
     824                 :            : 
     825                 :          0 :         if (!buffer) {
     826                 :          0 :                 for_each_xattr_handler(handlers, handler) {
     827                 :          0 :                         if (!handler->name ||
     828                 :          0 :                             (handler->list && !handler->list(dentry)))
     829                 :          0 :                                 continue;
     830                 :          0 :                         size += strlen(handler->name) + 1;
     831                 :            :                 }
     832                 :            :         } else {
     833                 :            :                 char *buf = buffer;
     834                 :            :                 size_t len;
     835                 :            : 
     836                 :          0 :                 for_each_xattr_handler(handlers, handler) {
     837                 :          0 :                         if (!handler->name ||
     838                 :          0 :                             (handler->list && !handler->list(dentry)))
     839                 :          0 :                                 continue;
     840                 :          0 :                         len = strlen(handler->name);
     841                 :          0 :                         if (len + 1 > buffer_size)
     842                 :            :                                 return -ERANGE;
     843                 :          0 :                         memcpy(buf, handler->name, len + 1);
     844                 :          0 :                         buf += len + 1;
     845                 :          0 :                         buffer_size -= len + 1;
     846                 :            :                 }
     847                 :          0 :                 size = buf - buffer;
     848                 :            :         }
     849                 :          0 :         return size;
     850                 :            : }
     851                 :            : EXPORT_SYMBOL(generic_listxattr);
     852                 :            : 
     853                 :            : /**
     854                 :            :  * xattr_full_name  -  Compute full attribute name from suffix
     855                 :            :  *
     856                 :            :  * @handler:    handler of the xattr_handler operation
     857                 :            :  * @name:       name passed to the xattr_handler operation
     858                 :            :  *
     859                 :            :  * The get and set xattr handler operations are called with the remainder of
     860                 :            :  * the attribute name after skipping the handler's prefix: for example, "foo"
     861                 :            :  * is passed to the get operation of a handler with prefix "user." to get
     862                 :            :  * attribute "user.foo".  The full name is still "there" in the name though.
     863                 :            :  *
     864                 :            :  * Note: the list xattr handler operation when called from the vfs is passed a
     865                 :            :  * NULL name; some file systems use this operation internally, with varying
     866                 :            :  * semantics.
     867                 :            :  */
     868                 :          3 : const char *xattr_full_name(const struct xattr_handler *handler,
     869                 :            :                             const char *name)
     870                 :            : {
     871                 :          3 :         size_t prefix_len = strlen(xattr_prefix(handler));
     872                 :            : 
     873                 :          3 :         return name - prefix_len;
     874                 :            : }
     875                 :            : EXPORT_SYMBOL(xattr_full_name);
     876                 :            : 
     877                 :            : /*
     878                 :            :  * Allocate new xattr and copy in the value; but leave the name to callers.
     879                 :            :  */
     880                 :          3 : struct simple_xattr *simple_xattr_alloc(const void *value, size_t size)
     881                 :            : {
     882                 :            :         struct simple_xattr *new_xattr;
     883                 :            :         size_t len;
     884                 :            : 
     885                 :            :         /* wrap around? */
     886                 :          3 :         len = sizeof(*new_xattr) + size;
     887                 :          3 :         if (len < sizeof(*new_xattr))
     888                 :            :                 return NULL;
     889                 :            : 
     890                 :            :         new_xattr = kmalloc(len, GFP_KERNEL);
     891                 :          3 :         if (!new_xattr)
     892                 :            :                 return NULL;
     893                 :            : 
     894                 :          3 :         new_xattr->size = size;
     895                 :          3 :         memcpy(new_xattr->value, value, size);
     896                 :          3 :         return new_xattr;
     897                 :            : }
     898                 :            : 
     899                 :            : /*
     900                 :            :  * xattr GET operation for in-memory/pseudo filesystems
     901                 :            :  */
     902                 :          3 : int simple_xattr_get(struct simple_xattrs *xattrs, const char *name,
     903                 :            :                      void *buffer, size_t size)
     904                 :            : {
     905                 :            :         struct simple_xattr *xattr;
     906                 :            :         int ret = -ENODATA;
     907                 :            : 
     908                 :            :         spin_lock(&xattrs->lock);
     909                 :          3 :         list_for_each_entry(xattr, &xattrs->head, list) {
     910                 :          0 :                 if (strcmp(name, xattr->name))
     911                 :          0 :                         continue;
     912                 :            : 
     913                 :          0 :                 ret = xattr->size;
     914                 :          0 :                 if (buffer) {
     915                 :          0 :                         if (size < xattr->size)
     916                 :            :                                 ret = -ERANGE;
     917                 :            :                         else
     918                 :          0 :                                 memcpy(buffer, xattr->value, xattr->size);
     919                 :            :                 }
     920                 :            :                 break;
     921                 :            :         }
     922                 :            :         spin_unlock(&xattrs->lock);
     923                 :          3 :         return ret;
     924                 :            : }
     925                 :            : 
     926                 :            : /**
     927                 :            :  * simple_xattr_set - xattr SET operation for in-memory/pseudo filesystems
     928                 :            :  * @xattrs: target simple_xattr list
     929                 :            :  * @name: name of the extended attribute
     930                 :            :  * @value: value of the xattr. If %NULL, will remove the attribute.
     931                 :            :  * @size: size of the new xattr
     932                 :            :  * @flags: %XATTR_{CREATE|REPLACE}
     933                 :            :  *
     934                 :            :  * %XATTR_CREATE is set, the xattr shouldn't exist already; otherwise fails
     935                 :            :  * with -EEXIST.  If %XATTR_REPLACE is set, the xattr should exist;
     936                 :            :  * otherwise, fails with -ENODATA.
     937                 :            :  *
     938                 :            :  * Returns 0 on success, -errno on failure.
     939                 :            :  */
     940                 :          3 : int simple_xattr_set(struct simple_xattrs *xattrs, const char *name,
     941                 :            :                      const void *value, size_t size, int flags)
     942                 :            : {
     943                 :            :         struct simple_xattr *xattr;
     944                 :            :         struct simple_xattr *new_xattr = NULL;
     945                 :            :         int err = 0;
     946                 :            : 
     947                 :            :         /* value == NULL means remove */
     948                 :          3 :         if (value) {
     949                 :          3 :                 new_xattr = simple_xattr_alloc(value, size);
     950                 :          3 :                 if (!new_xattr)
     951                 :            :                         return -ENOMEM;
     952                 :            : 
     953                 :          3 :                 new_xattr->name = kstrdup(name, GFP_KERNEL);
     954                 :          3 :                 if (!new_xattr->name) {
     955                 :          0 :                         kfree(new_xattr);
     956                 :          0 :                         return -ENOMEM;
     957                 :            :                 }
     958                 :            :         }
     959                 :            : 
     960                 :            :         spin_lock(&xattrs->lock);
     961                 :          3 :         list_for_each_entry(xattr, &xattrs->head, list) {
     962                 :          3 :                 if (!strcmp(name, xattr->name)) {
     963                 :          3 :                         if (flags & XATTR_CREATE) {
     964                 :            :                                 xattr = new_xattr;
     965                 :            :                                 err = -EEXIST;
     966                 :          3 :                         } else if (new_xattr) {
     967                 :          3 :                                 list_replace(&xattr->list, &new_xattr->list);
     968                 :            :                         } else {
     969                 :            :                                 list_del(&xattr->list);
     970                 :            :                         }
     971                 :            :                         goto out;
     972                 :            :                 }
     973                 :            :         }
     974                 :          3 :         if (flags & XATTR_REPLACE) {
     975                 :            :                 xattr = new_xattr;
     976                 :            :                 err = -ENODATA;
     977                 :            :         } else {
     978                 :          3 :                 list_add(&new_xattr->list, &xattrs->head);
     979                 :            :                 xattr = NULL;
     980                 :            :         }
     981                 :            : out:
     982                 :            :         spin_unlock(&xattrs->lock);
     983                 :          3 :         if (xattr) {
     984                 :          3 :                 kfree(xattr->name);
     985                 :          3 :                 kfree(xattr);
     986                 :            :         }
     987                 :          3 :         return err;
     988                 :            : 
     989                 :            : }
     990                 :            : 
     991                 :            : static bool xattr_is_trusted(const char *name)
     992                 :            : {
     993                 :          0 :         return !strncmp(name, XATTR_TRUSTED_PREFIX, XATTR_TRUSTED_PREFIX_LEN);
     994                 :            : }
     995                 :            : 
     996                 :          0 : static int xattr_list_one(char **buffer, ssize_t *remaining_size,
     997                 :            :                           const char *name)
     998                 :            : {
     999                 :          0 :         size_t len = strlen(name) + 1;
    1000                 :          0 :         if (*buffer) {
    1001                 :          0 :                 if (*remaining_size < len)
    1002                 :            :                         return -ERANGE;
    1003                 :          0 :                 memcpy(*buffer, name, len);
    1004                 :          0 :                 *buffer += len;
    1005                 :            :         }
    1006                 :          0 :         *remaining_size -= len;
    1007                 :          0 :         return 0;
    1008                 :            : }
    1009                 :            : 
    1010                 :            : /*
    1011                 :            :  * xattr LIST operation for in-memory/pseudo filesystems
    1012                 :            :  */
    1013                 :          0 : ssize_t simple_xattr_list(struct inode *inode, struct simple_xattrs *xattrs,
    1014                 :            :                           char *buffer, size_t size)
    1015                 :            : {
    1016                 :          0 :         bool trusted = capable(CAP_SYS_ADMIN);
    1017                 :            :         struct simple_xattr *xattr;
    1018                 :          0 :         ssize_t remaining_size = size;
    1019                 :            :         int err = 0;
    1020                 :            : 
    1021                 :            : #ifdef CONFIG_FS_POSIX_ACL
    1022                 :          0 :         if (IS_POSIXACL(inode)) {
    1023                 :          0 :                 if (inode->i_acl) {
    1024                 :          0 :                         err = xattr_list_one(&buffer, &remaining_size,
    1025                 :            :                                              XATTR_NAME_POSIX_ACL_ACCESS);
    1026                 :          0 :                         if (err)
    1027                 :            :                                 return err;
    1028                 :            :                 }
    1029                 :          0 :                 if (inode->i_default_acl) {
    1030                 :          0 :                         err = xattr_list_one(&buffer, &remaining_size,
    1031                 :            :                                              XATTR_NAME_POSIX_ACL_DEFAULT);
    1032                 :          0 :                         if (err)
    1033                 :            :                                 return err;
    1034                 :            :                 }
    1035                 :            :         }
    1036                 :            : #endif
    1037                 :            : 
    1038                 :            :         spin_lock(&xattrs->lock);
    1039                 :          0 :         list_for_each_entry(xattr, &xattrs->head, list) {
    1040                 :            :                 /* skip "trusted." attributes for unprivileged callers */
    1041                 :          0 :                 if (!trusted && xattr_is_trusted(xattr->name))
    1042                 :          0 :                         continue;
    1043                 :            : 
    1044                 :          0 :                 err = xattr_list_one(&buffer, &remaining_size, xattr->name);
    1045                 :          0 :                 if (err)
    1046                 :            :                         break;
    1047                 :            :         }
    1048                 :            :         spin_unlock(&xattrs->lock);
    1049                 :            : 
    1050                 :          0 :         return err ? err : size - remaining_size;
    1051                 :            : }
    1052                 :            : 
    1053                 :            : /*
    1054                 :            :  * Adds an extended attribute to the list
    1055                 :            :  */
    1056                 :          0 : void simple_xattr_list_add(struct simple_xattrs *xattrs,
    1057                 :            :                            struct simple_xattr *new_xattr)
    1058                 :            : {
    1059                 :            :         spin_lock(&xattrs->lock);
    1060                 :          0 :         list_add(&new_xattr->list, &xattrs->head);
    1061                 :            :         spin_unlock(&xattrs->lock);
    1062                 :          0 : }
    

Generated by: LCOV version 1.14