root/fs/cachefiles/xattr.c

DEFINITIONS

1. cachefiles_check_object_type
2. cachefiles_set_object_xattr
3. cachefiles_update_object_xattr
4. cachefiles_check_auxdata
5. cachefiles_check_object_xattr
6. cachefiles_remove_object_xattr

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /* CacheFiles extended attribute management
   3  *
   4  * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
   5  * Written by David Howells (dhowells@redhat.com)
   6  */
   7 
   8 #include <linux/module.h>
   9 #include <linux/sched.h>
  10 #include <linux/file.h>
  11 #include <linux/fs.h>
  12 #include <linux/fsnotify.h>
  13 #include <linux/quotaops.h>
  14 #include <linux/xattr.h>
  15 #include <linux/slab.h>
  16 #include "internal.h"
  17 
  18 static const char cachefiles_xattr_cache[] =
  19         XATTR_USER_PREFIX "CacheFiles.cache";
  20 
  21 /*
  22  * check the type label on an object
  23  * - done using xattrs
  24  */
  25 int cachefiles_check_object_type(struct cachefiles_object *object)
  26 {
  27         struct dentry *dentry = object->dentry;
  28         char type[3], xtype[3];
  29         int ret;
  30 
  31         ASSERT(dentry);
  32         ASSERT(d_backing_inode(dentry));
  33 
  34         if (!object->fscache.cookie)
  35                 strcpy(type, "C3");
  36         else
  37                 snprintf(type, 3, "%02x", object->fscache.cookie->def->type);
  38 
  39         _enter("%p{%s}", object, type);
  40 
  41         /* attempt to install a type label directly */
  42         ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
  43                            XATTR_CREATE);
  44         if (ret == 0) {
  45                 _debug("SET"); /* we succeeded */
  46                 goto error;
  47         }
  48 
  49         if (ret != -EEXIST) {
  50                 pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
  51                        dentry, d_backing_inode(dentry)->i_ino,
  52                        -ret);
  53                 goto error;
  54         }
  55 
  56         /* read the current type label */
  57         ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
  58         if (ret < 0) {
  59                 if (ret == -ERANGE)
  60                         goto bad_type_length;
  61 
  62                 pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
  63                        dentry, d_backing_inode(dentry)->i_ino,
  64                        -ret);
  65                 goto error;
  66         }
  67 
  68         /* check the type is what we're expecting */
  69         if (ret != 2)
  70                 goto bad_type_length;
  71 
  72         if (xtype[0] != type[0] || xtype[1] != type[1])
  73                 goto bad_type;
  74 
  75         ret = 0;
  76 
  77 error:
  78         _leave(" = %d", ret);
  79         return ret;
  80 
  81 bad_type_length:
  82         pr_err("Cache object %lu type xattr length incorrect\n",
  83                d_backing_inode(dentry)->i_ino);
  84         ret = -EIO;
  85         goto error;
  86 
  87 bad_type:
  88         xtype[2] = 0;
  89         pr_err("Cache object %pd [%lu] type %s not %s\n",
  90                dentry, d_backing_inode(dentry)->i_ino,
  91                xtype, type);
  92         ret = -EIO;
  93         goto error;
  94 }
  95 
  96 /*
  97  * set the state xattr on a cache file
  98  */
  99 int cachefiles_set_object_xattr(struct cachefiles_object *object,
 100                                 struct cachefiles_xattr *auxdata)
 101 {
 102         struct dentry *dentry = object->dentry;
 103         int ret;
 104 
 105         ASSERT(dentry);
 106 
 107         _enter("%p,#%d", object, auxdata->len);
 108 
 109         /* attempt to install the cache metadata directly */
 110         _debug("SET #%u", auxdata->len);
 111 
 112         clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
 113         ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
 114                            &auxdata->type, auxdata->len,
 115                            XATTR_CREATE);
 116         if (ret < 0 && ret != -ENOMEM)
 117                 cachefiles_io_error_obj(
 118                         object,
 119                         "Failed to set xattr with error %d", ret);
 120 
 121         _leave(" = %d", ret);
 122         return ret;
 123 }
 124 
 125 /*
 126  * update the state xattr on a cache file
 127  */
 128 int cachefiles_update_object_xattr(struct cachefiles_object *object,
 129                                    struct cachefiles_xattr *auxdata)
 130 {
 131         struct dentry *dentry = object->dentry;
 132         int ret;
 133 
 134         if (!dentry)
 135                 return -ESTALE;
 136 
 137         _enter("%p,#%d", object, auxdata->len);
 138 
 139         /* attempt to install the cache metadata directly */
 140         _debug("SET #%u", auxdata->len);
 141 
 142         clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
 143         ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
 144                            &auxdata->type, auxdata->len,
 145                            XATTR_REPLACE);
 146         if (ret < 0 && ret != -ENOMEM)
 147                 cachefiles_io_error_obj(
 148                         object,
 149                         "Failed to update xattr with error %d", ret);
 150 
 151         _leave(" = %d", ret);
 152         return ret;
 153 }
 154 
 155 /*
 156  * check the consistency between the backing cache and the FS-Cache cookie
 157  */
 158 int cachefiles_check_auxdata(struct cachefiles_object *object)
 159 {
 160         struct cachefiles_xattr *auxbuf;
 161         enum fscache_checkaux validity;
 162         struct dentry *dentry = object->dentry;
 163         ssize_t xlen;
 164         int ret;
 165 
 166         ASSERT(dentry);
 167         ASSERT(d_backing_inode(dentry));
 168         ASSERT(object->fscache.cookie->def->check_aux);
 169 
 170         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
 171         if (!auxbuf)
 172                 return -ENOMEM;
 173 
 174         xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
 175                             &auxbuf->type, 512 + 1);
 176         ret = -ESTALE;
 177         if (xlen < 1 ||
 178             auxbuf->type != object->fscache.cookie->def->type)
 179                 goto error;
 180 
 181         xlen--;
 182         validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
 183                                      i_size_read(d_backing_inode(dentry)));
 184         if (validity != FSCACHE_CHECKAUX_OKAY)
 185                 goto error;
 186 
 187         ret = 0;
 188 error:
 189         kfree(auxbuf);
 190         return ret;
 191 }
 192 
 193 /*
 194  * check the state xattr on a cache file
 195  * - return -ESTALE if the object should be deleted
 196  */
 197 int cachefiles_check_object_xattr(struct cachefiles_object *object,
 198                                   struct cachefiles_xattr *auxdata)
 199 {
 200         struct cachefiles_xattr *auxbuf;
 201         struct dentry *dentry = object->dentry;
 202         int ret;
 203 
 204         _enter("%p,#%d", object, auxdata->len);
 205 
 206         ASSERT(dentry);
 207         ASSERT(d_backing_inode(dentry));
 208 
 209         auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
 210         if (!auxbuf) {
 211                 _leave(" = -ENOMEM");
 212                 return -ENOMEM;
 213         }
 214 
 215         /* read the current type label */
 216         ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
 217                            &auxbuf->type, 512 + 1);
 218         if (ret < 0) {
 219                 if (ret == -ENODATA)
 220                         goto stale; /* no attribute - power went off
 221                                      * mid-cull? */
 222 
 223                 if (ret == -ERANGE)
 224                         goto bad_type_length;
 225 
 226                 cachefiles_io_error_obj(object,
 227                                         "Can't read xattr on %lu (err %d)",
 228                                         d_backing_inode(dentry)->i_ino, -ret);
 229                 goto error;
 230         }
 231 
 232         /* check the on-disk object */
 233         if (ret < 1)
 234                 goto bad_type_length;
 235 
 236         if (auxbuf->type != auxdata->type)
 237                 goto stale;
 238 
 239         auxbuf->len = ret;
 240 
 241         /* consult the netfs */
 242         if (object->fscache.cookie->def->check_aux) {
 243                 enum fscache_checkaux result;
 244                 unsigned int dlen;
 245 
 246                 dlen = auxbuf->len - 1;
 247 
 248                 _debug("checkaux %s #%u",
 249                        object->fscache.cookie->def->name, dlen);
 250 
 251                 result = fscache_check_aux(&object->fscache,
 252                                            &auxbuf->data, dlen,
 253                                            i_size_read(d_backing_inode(dentry)));
 254 
 255                 switch (result) {
 256                         /* entry okay as is */
 257                 case FSCACHE_CHECKAUX_OKAY:
 258                         goto okay;
 259 
 260                         /* entry requires update */
 261                 case FSCACHE_CHECKAUX_NEEDS_UPDATE:
 262                         break;
 263 
 264                         /* entry requires deletion */
 265                 case FSCACHE_CHECKAUX_OBSOLETE:
 266                         goto stale;
 267 
 268                 default:
 269                         BUG();
 270                 }
 271 
 272                 /* update the current label */
 273                 ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
 274                                    &auxdata->type, auxdata->len,
 275                                    XATTR_REPLACE);
 276                 if (ret < 0) {
 277                         cachefiles_io_error_obj(object,
 278                                                 "Can't update xattr on %lu"
 279                                                 " (error %d)",
 280                                                 d_backing_inode(dentry)->i_ino, -ret);
 281                         goto error;
 282                 }
 283         }
 284 
 285 okay:
 286         ret = 0;
 287 
 288 error:
 289         kfree(auxbuf);
 290         _leave(" = %d", ret);
 291         return ret;
 292 
 293 bad_type_length:
 294         pr_err("Cache object %lu xattr length incorrect\n",
 295                d_backing_inode(dentry)->i_ino);
 296         ret = -EIO;
 297         goto error;
 298 
 299 stale:
 300         ret = -ESTALE;
 301         goto error;
 302 }
 303 
 304 /*
 305  * remove the object's xattr to mark it stale
 306  */
 307 int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
 308                                    struct dentry *dentry)
 309 {
 310         int ret;
 311 
 312         ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
 313         if (ret < 0) {
 314                 if (ret == -ENOENT || ret == -ENODATA)
 315                         ret = 0;
 316                 else if (ret != -ENOMEM)
 317                         cachefiles_io_error(cache,
 318                                             "Can't remove xattr from %lu"
 319                                             " (error %d)",
 320                                             d_backing_inode(dentry)->i_ino, -ret);
 321         }
 322 
 323         _leave(" = %d", ret);
 324         return ret;
 325 }