path: root/fs/afs/inode.c

/*
 * Copyright (c) 2002 Red Hat, Inc. All rights reserved.
 *
 * This software may be freely redistributed under the terms of the
 * GNU General Public License.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Authors: David Woodhouse <dwmw2@infradead.org>
 *          David Howells <dhowells@redhat.com>
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/pagemap.h>
#include <linux/sched.h>
#include <linux/mount.h>
#include <linux/namei.h>
#include <linux/iversion.h>
#include "internal.h"
#include "afs_fs.h"

void afs_init_new_symlink(struct afs_vnode *vnode, struct afs_operation *op)
{
	size_t size = strlen(op->create.symlink) + 1;
	size_t dsize = 0;
	char *p;

	if (netfs_alloc_folioq_buffer(NULL, &vnode->directory, &dsize, size,
				      mapping_gfp_mask(vnode->netfs.inode.i_mapping)) < 0)
		return;

	vnode->directory_size = dsize;
	p = kmap_local_folio(folioq_folio(vnode->directory, 0), 0);
	memcpy(p, op->create.symlink, size);
	kunmap_local(p);
	set_bit(AFS_VNODE_DIR_READ, &vnode->flags);
	netfs_single_mark_inode_dirty(&vnode->netfs.inode);
}

static void afs_put_link(void *arg)
{
	struct folio *folio = virt_to_folio(arg);

	kunmap_local(arg);
	folio_put(folio);
}

const char *afs_get_link(struct dentry *dentry, struct inode *inode,
			 struct delayed_call *callback)
{
	struct afs_vnode *vnode = AFS_FS_I(inode);
	struct folio *folio;
	char *content;
	ssize_t ret;

	if (!dentry) {
		/* RCU pathwalk. */
		if (!test_bit(AFS_VNODE_DIR_READ, &vnode->flags) || !afs_check_validity(vnode))
			return ERR_PTR(-ECHILD);
		goto good;
	}

	if (test_bit(AFS_VNODE_DIR_READ, &vnode->flags))
		goto fetch;

	ret = afs_validate(vnode, NULL);
	if (ret < 0)
		return ERR_PTR(ret);

	if (!test_and_clear_bit(AFS_VNODE_ZAP_DATA, &vnode->flags) &&
	    test_bit(AFS_VNODE_DIR_READ, &vnode->flags))
		goto good;

fetch:
	ret = afs_read_single(vnode, NULL);
	if (ret < 0)
		return ERR_PTR(ret);
	set_bit(AFS_VNODE_DIR_READ, &vnode->flags);

good:
	folio = folioq_folio(vnode->directory, 0);
	folio_get(folio);
	content = kmap_local_folio(folio, 0);
	set_delayed_call(callback, afs_put_link, content);
	return content;
}

int afs_readlink(struct dentry *dentry, char __user *buffer, int buflen)
{
	DEFINE_DELAYED_CALL(done);
	const char *content;
	int len;

	content = afs_get_link(dentry, d_inode(dentry), &done);
	if (IS_ERR(content)) {
		do_delayed_call(&done);
		return PTR_ERR(content);
	}

	len = umin(strlen(content), buflen);
	if (copy_to_user(buffer, content, len))
		len = -EFAULT;
	do_delayed_call(&done);
	return len;
}

static const struct inode_operations afs_symlink_inode_operations = {
	.get_link	= afs_get_link,
	.readlink	= afs_readlink,
};

static noinline void dump_vnode(struct afs_vnode *vnode, struct afs_vnode *parent_vnode)
{
	static unsigned long once_only;

	pr_warn("kAFS: AFS vnode with undefined type %u\n", vnode->status.type);
	pr_warn("kAFS: A=%d m=%o s=%llx v=%llx\n",
		vnode->status.abort_code,
		vnode->status.mode,
		vnode->status.size,
		vnode->status.data_version);
	pr_warn("kAFS: vnode %llx:%llx:%x\n",
		vnode->fid.vid,
		vnode->fid.vnode,
		vnode->fid.unique);
	if (parent_vnode)
		pr_warn("kAFS: dir %llx:%llx:%x\n",
			parent_vnode->fid.vid,
			parent_vnode->fid.vnode,
			parent_vnode->fid.unique);

	if (!test_and_set_bit(0, &once_only))
		dump_stack();
}

/*
 * Set parameters for the netfs library
 */
static void afs_set_netfs_context(struct afs_vnode *vnode)
{
	netfs_inode_init(&vnode->netfs, &afs_req_ops, true);
}

/*
 * Initialise an inode from the vnode status.
 */
static int afs_inode_init_from_status