mirror of
https://github.com/AuxXxilium/linux_dsm_epyc7002.git
synced 2024-12-18 10:26:44 +07:00
e6bc06faf6
If cachefiles gets an error other then ENOENT when trying to look up an object in the cache (in this case, EACCES), the object state machine will eventually transition to the DROP_OBJECT state. This state invokes fscache_drop_object() which tries to sync the auxiliary data with the cache (this is done lazily since commit402cb8dda9
) on an incomplete cache object struct. The problem comes when cachefiles_update_object_xattr() is called to rewrite the xattr holding the data. There's an assertion there that the cache object points to a dentry as we're going to update its xattr. The assertion trips, however, as dentry didn't get set. Fix the problem by skipping the update in cachefiles if the object doesn't refer to a dentry. A better way to do it could be to skip the update from the DROP_OBJECT state handler in fscache, but that might deny the cache the opportunity to update intermediate state. If this error occurs, the kernel log includes lines that look like the following: CacheFiles: Lookup failed error -13 CacheFiles: CacheFiles: Assertion failed ------------[ cut here ]------------ kernel BUG at fs/cachefiles/xattr.c:138! ... Workqueue: fscache_object fscache_object_work_func [fscache] RIP: 0010:cachefiles_update_object_xattr.cold.4+0x18/0x1a [cachefiles] ... Call Trace: cachefiles_update_object+0xdd/0x1c0 [cachefiles] fscache_update_aux_data+0x23/0x30 [fscache] fscache_drop_object+0x18e/0x1c0 [fscache] fscache_object_work_func+0x74/0x2b0 [fscache] process_one_work+0x18d/0x340 worker_thread+0x2e/0x390 ? pwq_unbound_release_workfn+0xd0/0xd0 kthread+0x112/0x130 ? kthread_bind+0x30/0x30 ret_from_fork+0x35/0x40 Note that there are actually two issues here: (1) EACCES happened on a cache object and (2) an oops occurred. I think that the second is a consequence of the first (it certainly looks like it ought to be). This patch only deals with the second. Fixes:402cb8dda9
("fscache: Attach the index key and aux data to the cookie") Reported-by: Zhibin Li <zhibli@redhat.com> Signed-off-by: David Howells <dhowells@redhat.com>
330 lines
7.3 KiB
C
330 lines
7.3 KiB
C
/* CacheFiles extended attribute management
|
|
*
|
|
* Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public Licence
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the Licence, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/file.h>
|
|
#include <linux/fs.h>
|
|
#include <linux/fsnotify.h>
|
|
#include <linux/quotaops.h>
|
|
#include <linux/xattr.h>
|
|
#include <linux/slab.h>
|
|
#include "internal.h"
|
|
|
|
static const char cachefiles_xattr_cache[] =
|
|
XATTR_USER_PREFIX "CacheFiles.cache";
|
|
|
|
/*
|
|
* check the type label on an object
|
|
* - done using xattrs
|
|
*/
|
|
int cachefiles_check_object_type(struct cachefiles_object *object)
|
|
{
|
|
struct dentry *dentry = object->dentry;
|
|
char type[3], xtype[3];
|
|
int ret;
|
|
|
|
ASSERT(dentry);
|
|
ASSERT(d_backing_inode(dentry));
|
|
|
|
if (!object->fscache.cookie)
|
|
strcpy(type, "C3");
|
|
else
|
|
snprintf(type, 3, "%02x", object->fscache.cookie->def->type);
|
|
|
|
_enter("%p{%s}", object, type);
|
|
|
|
/* attempt to install a type label directly */
|
|
ret = vfs_setxattr(dentry, cachefiles_xattr_cache, type, 2,
|
|
XATTR_CREATE);
|
|
if (ret == 0) {
|
|
_debug("SET"); /* we succeeded */
|
|
goto error;
|
|
}
|
|
|
|
if (ret != -EEXIST) {
|
|
pr_err("Can't set xattr on %pd [%lu] (err %d)\n",
|
|
dentry, d_backing_inode(dentry)->i_ino,
|
|
-ret);
|
|
goto error;
|
|
}
|
|
|
|
/* read the current type label */
|
|
ret = vfs_getxattr(dentry, cachefiles_xattr_cache, xtype, 3);
|
|
if (ret < 0) {
|
|
if (ret == -ERANGE)
|
|
goto bad_type_length;
|
|
|
|
pr_err("Can't read xattr on %pd [%lu] (err %d)\n",
|
|
dentry, d_backing_inode(dentry)->i_ino,
|
|
-ret);
|
|
goto error;
|
|
}
|
|
|
|
/* check the type is what we're expecting */
|
|
if (ret != 2)
|
|
goto bad_type_length;
|
|
|
|
if (xtype[0] != type[0] || xtype[1] != type[1])
|
|
goto bad_type;
|
|
|
|
ret = 0;
|
|
|
|
error:
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
bad_type_length:
|
|
pr_err("Cache object %lu type xattr length incorrect\n",
|
|
d_backing_inode(dentry)->i_ino);
|
|
ret = -EIO;
|
|
goto error;
|
|
|
|
bad_type:
|
|
xtype[2] = 0;
|
|
pr_err("Cache object %pd [%lu] type %s not %s\n",
|
|
dentry, d_backing_inode(dentry)->i_ino,
|
|
xtype, type);
|
|
ret = -EIO;
|
|
goto error;
|
|
}
|
|
|
|
/*
|
|
* set the state xattr on a cache file
|
|
*/
|
|
int cachefiles_set_object_xattr(struct cachefiles_object *object,
|
|
struct cachefiles_xattr *auxdata)
|
|
{
|
|
struct dentry *dentry = object->dentry;
|
|
int ret;
|
|
|
|
ASSERT(dentry);
|
|
|
|
_enter("%p,#%d", object, auxdata->len);
|
|
|
|
/* attempt to install the cache metadata directly */
|
|
_debug("SET #%u", auxdata->len);
|
|
|
|
clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
|
|
ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
|
|
&auxdata->type, auxdata->len,
|
|
XATTR_CREATE);
|
|
if (ret < 0 && ret != -ENOMEM)
|
|
cachefiles_io_error_obj(
|
|
object,
|
|
"Failed to set xattr with error %d", ret);
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* update the state xattr on a cache file
|
|
*/
|
|
int cachefiles_update_object_xattr(struct cachefiles_object *object,
|
|
struct cachefiles_xattr *auxdata)
|
|
{
|
|
struct dentry *dentry = object->dentry;
|
|
int ret;
|
|
|
|
if (!dentry)
|
|
return -ESTALE;
|
|
|
|
_enter("%p,#%d", object, auxdata->len);
|
|
|
|
/* attempt to install the cache metadata directly */
|
|
_debug("SET #%u", auxdata->len);
|
|
|
|
clear_bit(FSCACHE_COOKIE_AUX_UPDATED, &object->fscache.cookie->flags);
|
|
ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
|
|
&auxdata->type, auxdata->len,
|
|
XATTR_REPLACE);
|
|
if (ret < 0 && ret != -ENOMEM)
|
|
cachefiles_io_error_obj(
|
|
object,
|
|
"Failed to update xattr with error %d", ret);
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* check the consistency between the backing cache and the FS-Cache cookie
|
|
*/
|
|
int cachefiles_check_auxdata(struct cachefiles_object *object)
|
|
{
|
|
struct cachefiles_xattr *auxbuf;
|
|
enum fscache_checkaux validity;
|
|
struct dentry *dentry = object->dentry;
|
|
ssize_t xlen;
|
|
int ret;
|
|
|
|
ASSERT(dentry);
|
|
ASSERT(d_backing_inode(dentry));
|
|
ASSERT(object->fscache.cookie->def->check_aux);
|
|
|
|
auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, GFP_KERNEL);
|
|
if (!auxbuf)
|
|
return -ENOMEM;
|
|
|
|
xlen = vfs_getxattr(dentry, cachefiles_xattr_cache,
|
|
&auxbuf->type, 512 + 1);
|
|
ret = -ESTALE;
|
|
if (xlen < 1 ||
|
|
auxbuf->type != object->fscache.cookie->def->type)
|
|
goto error;
|
|
|
|
xlen--;
|
|
validity = fscache_check_aux(&object->fscache, &auxbuf->data, xlen,
|
|
i_size_read(d_backing_inode(dentry)));
|
|
if (validity != FSCACHE_CHECKAUX_OKAY)
|
|
goto error;
|
|
|
|
ret = 0;
|
|
error:
|
|
kfree(auxbuf);
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* check the state xattr on a cache file
|
|
* - return -ESTALE if the object should be deleted
|
|
*/
|
|
int cachefiles_check_object_xattr(struct cachefiles_object *object,
|
|
struct cachefiles_xattr *auxdata)
|
|
{
|
|
struct cachefiles_xattr *auxbuf;
|
|
struct dentry *dentry = object->dentry;
|
|
int ret;
|
|
|
|
_enter("%p,#%d", object, auxdata->len);
|
|
|
|
ASSERT(dentry);
|
|
ASSERT(d_backing_inode(dentry));
|
|
|
|
auxbuf = kmalloc(sizeof(struct cachefiles_xattr) + 512, cachefiles_gfp);
|
|
if (!auxbuf) {
|
|
_leave(" = -ENOMEM");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
/* read the current type label */
|
|
ret = vfs_getxattr(dentry, cachefiles_xattr_cache,
|
|
&auxbuf->type, 512 + 1);
|
|
if (ret < 0) {
|
|
if (ret == -ENODATA)
|
|
goto stale; /* no attribute - power went off
|
|
* mid-cull? */
|
|
|
|
if (ret == -ERANGE)
|
|
goto bad_type_length;
|
|
|
|
cachefiles_io_error_obj(object,
|
|
"Can't read xattr on %lu (err %d)",
|
|
d_backing_inode(dentry)->i_ino, -ret);
|
|
goto error;
|
|
}
|
|
|
|
/* check the on-disk object */
|
|
if (ret < 1)
|
|
goto bad_type_length;
|
|
|
|
if (auxbuf->type != auxdata->type)
|
|
goto stale;
|
|
|
|
auxbuf->len = ret;
|
|
|
|
/* consult the netfs */
|
|
if (object->fscache.cookie->def->check_aux) {
|
|
enum fscache_checkaux result;
|
|
unsigned int dlen;
|
|
|
|
dlen = auxbuf->len - 1;
|
|
|
|
_debug("checkaux %s #%u",
|
|
object->fscache.cookie->def->name, dlen);
|
|
|
|
result = fscache_check_aux(&object->fscache,
|
|
&auxbuf->data, dlen,
|
|
i_size_read(d_backing_inode(dentry)));
|
|
|
|
switch (result) {
|
|
/* entry okay as is */
|
|
case FSCACHE_CHECKAUX_OKAY:
|
|
goto okay;
|
|
|
|
/* entry requires update */
|
|
case FSCACHE_CHECKAUX_NEEDS_UPDATE:
|
|
break;
|
|
|
|
/* entry requires deletion */
|
|
case FSCACHE_CHECKAUX_OBSOLETE:
|
|
goto stale;
|
|
|
|
default:
|
|
BUG();
|
|
}
|
|
|
|
/* update the current label */
|
|
ret = vfs_setxattr(dentry, cachefiles_xattr_cache,
|
|
&auxdata->type, auxdata->len,
|
|
XATTR_REPLACE);
|
|
if (ret < 0) {
|
|
cachefiles_io_error_obj(object,
|
|
"Can't update xattr on %lu"
|
|
" (error %d)",
|
|
d_backing_inode(dentry)->i_ino, -ret);
|
|
goto error;
|
|
}
|
|
}
|
|
|
|
okay:
|
|
ret = 0;
|
|
|
|
error:
|
|
kfree(auxbuf);
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
|
|
bad_type_length:
|
|
pr_err("Cache object %lu xattr length incorrect\n",
|
|
d_backing_inode(dentry)->i_ino);
|
|
ret = -EIO;
|
|
goto error;
|
|
|
|
stale:
|
|
ret = -ESTALE;
|
|
goto error;
|
|
}
|
|
|
|
/*
|
|
* remove the object's xattr to mark it stale
|
|
*/
|
|
int cachefiles_remove_object_xattr(struct cachefiles_cache *cache,
|
|
struct dentry *dentry)
|
|
{
|
|
int ret;
|
|
|
|
ret = vfs_removexattr(dentry, cachefiles_xattr_cache);
|
|
if (ret < 0) {
|
|
if (ret == -ENOENT || ret == -ENODATA)
|
|
ret = 0;
|
|
else if (ret != -ENOMEM)
|
|
cachefiles_io_error(cache,
|
|
"Can't remove xattr from %lu"
|
|
" (error %d)",
|
|
d_backing_inode(dentry)->i_ino, -ret);
|
|
}
|
|
|
|
_leave(" = %d", ret);
|
|
return ret;
|
|
}
|