mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2026-03-03 18:28:01 +01:00
bf4afc53b7
This was done entirely with mindless brute force, using
git grep -l '\<k[vmz]*alloc_objs*(.*, GFP_KERNEL)' |
xargs sed -i 's/\(alloc_objs*(.*\), GFP_KERNEL)/\1)/'
to convert the new alloc_obj() users that had a simple GFP_KERNEL
argument to just drop that argument.
Note that due to the extreme simplicity of the scripting, any slightly
more complex cases spread over multiple lines would not be triggered:
they definitely exist, but this covers the vast bulk of the cases, and
the resulting diff is also then easier to check automatically.
For the same reason the 'flex' versions will be done as a separate
conversion.
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
142 lines
3.3 KiB
C
142 lines
3.3 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/* Volume handling.
|
|
*
|
|
* Copyright (C) 2021 Red Hat, Inc. All Rights Reserved.
|
|
* Written by David Howells (dhowells@redhat.com)
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/namei.h>
|
|
#include "internal.h"
|
|
#include <trace/events/fscache.h>
|
|
|
|
/*
|
|
* Allocate and set up a volume representation. We make sure all the fanout
|
|
* directories are created and pinned.
|
|
*/
|
|
void cachefiles_acquire_volume(struct fscache_volume *vcookie)
|
|
{
|
|
struct cachefiles_volume *volume;
|
|
struct cachefiles_cache *cache = vcookie->cache->cache_priv;
|
|
const struct cred *saved_cred;
|
|
struct dentry *vdentry, *fan;
|
|
size_t len;
|
|
char *name;
|
|
bool is_new = false;
|
|
int ret, n_accesses, i;
|
|
|
|
_enter("");
|
|
|
|
volume = kzalloc_obj(struct cachefiles_volume);
|
|
if (!volume)
|
|
return;
|
|
volume->vcookie = vcookie;
|
|
volume->cache = cache;
|
|
INIT_LIST_HEAD(&volume->cache_link);
|
|
|
|
cachefiles_begin_secure(cache, &saved_cred);
|
|
|
|
len = vcookie->key[0];
|
|
name = kmalloc(len + 3, GFP_NOFS);
|
|
if (!name)
|
|
goto error_vol;
|
|
name[0] = 'I';
|
|
memcpy(name + 1, vcookie->key + 1, len);
|
|
name[len + 1] = 0;
|
|
|
|
retry:
|
|
vdentry = cachefiles_get_directory(cache, cache->store, name, &is_new);
|
|
if (IS_ERR(vdentry))
|
|
goto error_name;
|
|
volume->dentry = vdentry;
|
|
|
|
if (is_new) {
|
|
if (!cachefiles_set_volume_xattr(volume))
|
|
goto error_dir;
|
|
} else {
|
|
ret = cachefiles_check_volume_xattr(volume);
|
|
if (ret < 0) {
|
|
if (ret != -ESTALE)
|
|
goto error_dir;
|
|
vdentry = start_removing_dentry(cache->store, vdentry);
|
|
if (!IS_ERR(vdentry))
|
|
cachefiles_bury_object(cache, NULL, cache->store,
|
|
vdentry,
|
|
FSCACHE_VOLUME_IS_WEIRD);
|
|
cachefiles_put_directory(volume->dentry);
|
|
cond_resched();
|
|
goto retry;
|
|
}
|
|
}
|
|
|
|
for (i = 0; i < 256; i++) {
|
|
sprintf(name, "@%02x", i);
|
|
fan = cachefiles_get_directory(cache, vdentry, name, NULL);
|
|
if (IS_ERR(fan))
|
|
goto error_fan;
|
|
volume->fanout[i] = fan;
|
|
}
|
|
|
|
cachefiles_end_secure(cache, saved_cred);
|
|
|
|
vcookie->cache_priv = volume;
|
|
n_accesses = atomic_inc_return(&vcookie->n_accesses); /* Stop wakeups on dec-to-0 */
|
|
trace_fscache_access_volume(vcookie->debug_id, 0,
|
|
refcount_read(&vcookie->ref),
|
|
n_accesses, fscache_access_cache_pin);
|
|
|
|
spin_lock(&cache->object_list_lock);
|
|
list_add(&volume->cache_link, &volume->cache->volumes);
|
|
spin_unlock(&cache->object_list_lock);
|
|
|
|
kfree(name);
|
|
return;
|
|
|
|
error_fan:
|
|
for (i = 0; i < 256; i++)
|
|
cachefiles_put_directory(volume->fanout[i]);
|
|
error_dir:
|
|
cachefiles_put_directory(volume->dentry);
|
|
error_name:
|
|
kfree(name);
|
|
error_vol:
|
|
kfree(volume);
|
|
cachefiles_end_secure(cache, saved_cred);
|
|
}
|
|
|
|
/*
|
|
* Release a volume representation.
|
|
*/
|
|
static void __cachefiles_free_volume(struct cachefiles_volume *volume)
|
|
{
|
|
int i;
|
|
|
|
_enter("");
|
|
|
|
volume->vcookie->cache_priv = NULL;
|
|
|
|
for (i = 0; i < 256; i++)
|
|
cachefiles_put_directory(volume->fanout[i]);
|
|
cachefiles_put_directory(volume->dentry);
|
|
kfree(volume);
|
|
}
|
|
|
|
void cachefiles_free_volume(struct fscache_volume *vcookie)
|
|
{
|
|
struct cachefiles_volume *volume = vcookie->cache_priv;
|
|
|
|
if (volume) {
|
|
spin_lock(&volume->cache->object_list_lock);
|
|
list_del_init(&volume->cache_link);
|
|
spin_unlock(&volume->cache->object_list_lock);
|
|
__cachefiles_free_volume(volume);
|
|
}
|
|
}
|
|
|
|
void cachefiles_withdraw_volume(struct cachefiles_volume *volume)
|
|
{
|
|
cachefiles_set_volume_xattr(volume);
|
|
__cachefiles_free_volume(volume);
|
|
}
|