From patchwork Fri Oct 22 19:07:31 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: David Howells X-Patchwork-Id: 12578809 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E5D88C433EF for ; Fri, 22 Oct 2021 19:08:22 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id C809D61038 for ; Fri, 22 Oct 2021 19:08:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233799AbhJVTKa (ORCPT ); Fri, 22 Oct 2021 15:10:30 -0400 Received: from us-smtp-delivery-124.mimecast.com ([170.10.133.124]:56626 "EHLO us-smtp-delivery-124.mimecast.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234179AbhJVTKD (ORCPT ); Fri, 22 Oct 2021 15:10:03 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1634929665; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=JH5U06J+jBtzM7E+T1W282ZqeNfTrBwNbqexnEyNrKs=; b=TlI5gNAC89H+8rcKssLjwvEUQhAeVVuRljx6EIW9RUL6vB5VIpumAdvULCveIsIKvzB/j6 PA87bBXxTMYwAhp6RINWu3JGRfUkg9GEvX2Kka2LXx1WCZf9mqFt6614Sbp3oxEUJF7417 AirefHIKG2HgWn8DuBneB0f8T05RdDI= Received: from mimecast-mx01.redhat.com (mimecast-mx01.redhat.com [209.132.183.4]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-46-whylEpMOMxysyhwKKvRT2g-1; Fri, 22 Oct 2021 15:07:40 -0400 X-MC-Unique: whylEpMOMxysyhwKKvRT2g-1 Received: from smtp.corp.redhat.com (int-mx06.intmail.prod.int.phx2.redhat.com [10.5.11.16]) (using TLSv1.2 with cipher AECDH-AES256-SHA (256/256 bits)) (No client certificate requested) by mimecast-mx01.redhat.com (Postfix) with ESMTPS id DEE15108087A; Fri, 22 Oct 2021 19:07:37 +0000 (UTC) Received: from warthog.procyon.org.uk (unknown [10.33.36.19]) by smtp.corp.redhat.com (Postfix) with ESMTP id 579C65C1A3; Fri, 22 Oct 2021 19:07:32 +0000 (UTC) Organization: Red Hat UK Ltd. Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SI4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 3798903 Subject: [PATCH v2 37/53] cachefiles: Implement volume support From: David Howells To: linux-cachefs@redhat.com Cc: dhowells@redhat.com, Trond Myklebust , Anna Schumaker , Steve French , Dominique Martinet , Jeff Layton , Matthew Wilcox , Alexander Viro , Omar Sandoval , Linus Torvalds , linux-afs@lists.infradead.org, linux-nfs@vger.kernel.org, linux-cifs@vger.kernel.org, ceph-devel@vger.kernel.org, v9fs-developer@lists.sourceforge.net, linux-fsdevel@vger.kernel.org, linux-kernel@vger.kernel.org Date: Fri, 22 Oct 2021 20:07:31 +0100 Message-ID: <163492965148.1038219.9649181508116300227.stgit@warthog.procyon.org.uk> In-Reply-To: <163492911924.1038219.13107463173777870713.stgit@warthog.procyon.org.uk> References: <163492911924.1038219.13107463173777870713.stgit@warthog.procyon.org.uk> User-Agent: StGit/0.23 MIME-Version: 1.0 X-Scanned-By: MIMEDefang 2.79 on 10.5.11.16 Precedence: bulk List-ID: X-Mailing-List: linux-nfs@vger.kernel.org Implement support for creating the directory layout for a volume on disk and setting up and withdrawing volume caching. Each volume has a directory named for the volume key under the root of the cache (prefixed with an 'I' to indicate to cachefilesd that it's an index) and then creates a bunch of hash bucket subdirectories under that (named as '@' plus a hex number) in which cookie files will be created. Signed-off-by: David Howells cc: linux-cachefs@redhat.com --- fs/cachefiles/Makefile | 3 + fs/cachefiles/bind.c | 28 +++++++++- fs/cachefiles/interface.c | 2 + fs/cachefiles/internal.h | 7 ++ fs/cachefiles/volume.c | 128 +++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 166 insertions(+), 2 deletions(-) create mode 100644 fs/cachefiles/volume.c diff --git a/fs/cachefiles/Makefile b/fs/cachefiles/Makefile index 7017c9113074..607f7c684a97 100644 --- a/fs/cachefiles/Makefile +++ b/fs/cachefiles/Makefile @@ -9,7 +9,8 @@ cachefiles-y := \ interface.o \ main.o \ namei.o \ - security.o + security.o \ + volume.o cachefiles-$(CONFIG_CACHEFILES_ERROR_INJECTION) += error_inject.o diff --git a/fs/cachefiles/bind.c b/fs/cachefiles/bind.c index 9ca10290064b..70924997b0cc 100644 --- a/fs/cachefiles/bind.c +++ b/fs/cachefiles/bind.c @@ -236,6 +236,32 @@ static int cachefiles_daemon_add_cache(struct cachefiles_cache *cache) return ret; } +/* + * Withdraw volumes. + */ +static void cachefiles_withdraw_volumes(struct cachefiles_cache *cache) +{ + _enter(""); + + for (;;) { + struct cachefiles_volume *volume = NULL; + + spin_lock(&cache->object_list_lock); + if (!list_empty(&cache->volumes)) { + volume = list_first_entry(&cache->volumes, + struct cachefiles_volume, cache_link); + list_del_init(&volume->cache_link); + } + spin_unlock(&cache->object_list_lock); + if (!volume) + break; + + cachefiles_withdraw_volume(volume); + } + + _leave(""); +} + /* * Withdraw cache objects. */ @@ -259,7 +285,7 @@ static void cachefiles_withdraw_cache(struct cachefiles_cache *cache) atomic_read(&fscache->object_count) == 0); _debug("cleared"); - // PLACEHOLDER: Withdraw volume + cachefiles_withdraw_volumes(cache); /* make sure all outstanding data is written to disk */ cachefiles_sync_cache(cache); diff --git a/fs/cachefiles/interface.c b/fs/cachefiles/interface.c index 236d55c13fb1..8624ee52b98b 100644 --- a/fs/cachefiles/interface.c +++ b/fs/cachefiles/interface.c @@ -39,4 +39,6 @@ void cachefiles_sync_cache(struct cachefiles_cache *cache) const struct fscache_cache_ops cachefiles_cache_ops = { .name = "cachefiles", + .acquire_volume = cachefiles_acquire_volume, + .free_volume = cachefiles_free_volume, }; diff --git a/fs/cachefiles/internal.h b/fs/cachefiles/internal.h index c472766cdce3..828b888a8bf3 100644 --- a/fs/cachefiles/internal.h +++ b/fs/cachefiles/internal.h @@ -211,6 +211,13 @@ static inline void cachefiles_end_secure(struct cachefiles_cache *cache, revert_creds(saved_cred); } +/* + * volume.c + */ +void cachefiles_acquire_volume(struct fscache_volume *volume); +void cachefiles_free_volume(struct fscache_volume *volume); +void cachefiles_withdraw_volume(struct cachefiles_volume *volume); + /* * error handling */ diff --git a/fs/cachefiles/volume.c b/fs/cachefiles/volume.c new file mode 100644 index 000000000000..f5e527b56228 --- /dev/null +++ b/fs/cachefiles/volume.c @@ -0,0 +1,128 @@ +// 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 +#include +#include "internal.h" +#include + +/* + * 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; + int n_accesses, i; + + _enter(""); + + volume = kzalloc(sizeof(struct cachefiles_volume), GFP_KERNEL); + 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; + + vdentry = cachefiles_get_directory(cache, cache->store, name); + if (IS_ERR(vdentry)) + goto error_name; + volume->dentry = vdentry; + + for (i = 0; i < 256; i++) { + sprintf(name, "@%02x", i); + fan = cachefiles_get_directory(cache, vdentry, name); + 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, 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++) + dput(volume->fanout[i]); + dput(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++) + dput(volume->fanout[i]); + dput(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) +{ + struct fscache_volume *vcookie = volume->vcookie; + int n_accesses; + + _debug("withdraw V=%x", vcookie->debug_id); + + /* Allow wakeups on dec-to-0 */ + n_accesses = atomic_dec_return(&vcookie->n_accesses); + trace_fscache_access_volume(vcookie->debug_id, refcount_read(&vcookie->ref), + n_accesses, fscache_access_cache_unpin); + + wait_var_event(&vcookie->n_accesses, + atomic_read(&vcookie->n_accesses) == 0); + __cachefiles_free_volume(volume); +}