// 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);
}