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 } 326