[mirror_ubuntu-hirsute-kernel.git] / fs / afs / fs_operation.c

// SPDX-License-Identifier: GPL-2.0-or-later
/* Fileserver-directed operation handling.
 *
 * Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 */

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include "internal.h"

static atomic_t afs_operation_debug_counter;

/*
 * Create an operation against a volume.
 */
struct afs_operation *afs_alloc_operation(struct key *key, struct afs_volume *volume)
{
	struct afs_operation *op;

	_enter("");

	op = kzalloc(sizeof(*op), GFP_KERNEL);
	if (!op)
		return ERR_PTR(-ENOMEM);

	if (!key) {
		key = afs_request_key(volume->cell);
		if (IS_ERR(key)) {
			kfree(op);
			return ERR_CAST(key);
		}
	} else {
		key_get(key);
	}

	op->key		= key;
	op->volume	= afs_get_volume(volume, afs_volume_trace_get_new_op);
	op->net		= volume->cell->net;
	op->cb_v_break	= volume->cb_v_break;
	op->debug_id	= atomic_inc_return(&afs_operation_debug_counter);
	op->error	= -EDESTADDRREQ;
	op->ac.error	= SHRT_MAX;

	_leave(" = [op=%08x]", op->debug_id);
	return op;
}

/*
 * Lock the vnode(s) being operated upon.
 */
static bool afs_get_io_locks(struct afs_operation *op)
{
	struct afs_vnode *vnode = op->file[0].vnode;
	struct afs_vnode *vnode2 = op->file[1].vnode;

	_enter("");

	if (op->flags & AFS_OPERATION_UNINTR) {
		mutex_lock(&vnode->io_lock);
		op->flags |= AFS_OPERATION_LOCK_0;
		_leave(" = t [1]");
		return true;
	}

	if (!vnode2 || !op->file[1].need_io_lock || vnode == vnode2)
		vnode2 = NULL;

	if (vnode2 > vnode)
		swap(vnode, vnode2);

	if (mutex_lock_interruptible(&vnode->io_lock) < 0) {
		op->error = -ERESTARTSYS;
		op->flags |= AFS_OPERATION_STOP;
		_leave(" = f [I 0]");
		return false;
	}
	op->flags |= AFS_OPERATION_LOCK_0;

	if (vnode2) {
		if (mutex_lock_interruptible_nested(&vnode2->io_lock, 1) < 0) {
			op->error = -ERESTARTSYS;
			op->flags |= AFS_OPERATION_STOP;
			mutex_unlock(&vnode->io_lock);
			op->flags &= ~AFS_OPERATION_LOCK_0;
			_leave(" = f [I 1]");
			return false;
		}
		op->flags |= AFS_OPERATION_LOCK_1;
	}

	_leave(" = t [2]");
	return true;
}

static void afs_drop_io_locks(struct afs_operation *op)
{
	struct afs_vnode *vnode = op->file[0].vnode;
	struct afs_vnode *vnode2 = op->file[1].vnode;

	_enter("");

	if (op->flags & AFS_OPERATION_LOCK_1)
		mutex_unlock(&vnode2->io_lock);
	if (op->flags & AFS_OPERATION_LOCK_0)
		mutex_unlock(&vnode->io_lock);
}

static void afs_prepare_vnode(struct afs_operation *op, struct afs_vnode_param *vp,
			      unsigned int index)
{
	struct afs_vnode *vnode = vp->vnode;

	if (vnode) {
		vp->fid			= vnode->fid;
		vp->dv_before		= vnode->status.data_version;
		vp->cb_break_before	= afs_calc_vnode_cb_break(vnode);
		if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
			op->flags	|= AFS_OPERATION_CUR_ONLY;
	}

	if (vp->fid.vnode)
		_debug("PREP[%u] {%llx:%llu.%u}",
		       index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
}

/*
 * Begin an operation on the fileserver.
 *
 * Fileserver operations are serialised on the server by vnode, so we serialise
 * them here also using the io_lock.
 */
bool afs_begin_vnode_operation(struct afs_operation *op)
{
	struct afs_vnode *vnode = op->file[0].vnode;

	ASSERT(vnode);

	_enter("");

	if (op->file[0].need_io_lock)
		if (!afs_get_io_locks(op))
			return false;

	afs_prepare_vnode(op, &op->file[0], 0);
	afs_prepare_vnode(op, &op->file[1], 1);
	op->cb_v_break = op->volume->cb_v_break;
	_leave(" = true");
	return true;
}

/*
 * Tidy up a filesystem cursor and unlock the vnode.
 */
static void afs_end_vnode_operation(struct afs_operation *op)
{
	_enter("");

	if (op->error == -EDESTADDRREQ ||
	    op->error == -EADDRNOTAVAIL ||
	    op->error == -ENETUNREACH ||
	    op->error == -EHOSTUNREACH)
		afs_dump_edestaddrreq(op);

	afs_drop_io_locks(op);

	if (op->error == -ECONNABORTED)
		op->error = afs_abort_to_error(op->ac.abort_code);
}

/*
 * Wait for an in-progress operation to complete.
 */
void afs_wait_for_operation(struct afs_operation *op)
{
	_enter("");

	while (afs_select_fileserver(op)) {
		op->cb_s_break = op->server->cb_s_break;
		if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
		    op->ops->issue_yfs_rpc)
			op->ops->issue_yfs_rpc(op);
		else if (op->ops->issue_afs_rpc)
			op->ops->issue_afs_rpc(op);
		else
			op->ac.error = -ENOTSUPP;

		if (op->call)
			op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
	}

	switch (op->error) {
	case 0:
		_debug("success");
		op->ops->success(op);
		break;
	case -ECONNABORTED:
		if (op->ops->aborted)
			op->ops->aborted(op);
		break;
	default:
		break;
	}

	afs_end_vnode_operation(op);

	if (op->error == 0 && op->ops->edit_dir) {
		_debug("edit_dir");
		op->ops->edit_dir(op);
	}
	_leave("");
}

/*
 * Dispose of an operation.
 */
int afs_put_operation(struct afs_operation *op)
{
	int i, ret = op->error;

	_enter("op=%08x,%d", op->debug_id, ret);

	if (op->ops && op->ops->put)
		op->ops->put(op);
	if (op->file[0].put_vnode)
		iput(&op->file[0].vnode->vfs_inode);
	if (op->file[1].put_vnode)
		iput(&op->file[1].vnode->vfs_inode);

	if (op->more_files) {
		for (i = 0; i < op->nr_files - 2; i++)
			if (op->more_files[i].put_vnode)
				iput(&op->more_files[i].vnode->vfs_inode);
		kfree(op->more_files);
	}

	afs_end_cursor(&op->ac);
	afs_put_serverlist(op->net, op->server_list);
	afs_put_volume(op->net, op->volume, afs_volume_trace_put_put_op);
	key_put(op->key);
	kfree(op);
	return ret;
}

int afs_do_sync_operation(struct afs_operation *op)
{
	afs_begin_vnode_operation(op);
	afs_wait_for_operation(op);
	return afs_put_operation(op);
}
Commit	Line	Data
e49c7b2f DH	1	// SPDX-License-Identifier: GPL-2.0-or-later
	2	/* Fileserver-directed operation handling.
	3	*
	4	* Copyright (C) 2020 Red Hat, Inc. All Rights Reserved.
	5	* Written by David Howells (dhowells@redhat.com)
	6	*/
	7
	8	#include <linux/kernel.h>
	9	#include <linux/slab.h>
	10	#include <linux/fs.h>
	11	#include "internal.h"
	12
	13	static atomic_t afs_operation_debug_counter;
	14
	15	/*
	16	* Create an operation against a volume.
	17	*/
	18	struct afs_operation afs_alloc_operation(struct key key, struct afs_volume *volume)
	19	{
	20	struct afs_operation *op;
	21
	22	_enter("");
	23
	24	op = kzalloc(sizeof(*op), GFP_KERNEL);
	25	if (!op)
	26	return ERR_PTR(-ENOMEM);
	27
	28	if (!key) {
	29	key = afs_request_key(volume->cell);
	30	if (IS_ERR(key)) {
	31	kfree(op);
	32	return ERR_CAST(key);
	33	}
	34	} else {
	35	key_get(key);
	36	}
	37
	38	op->key = key;
cca37d45	39	op->volume = afs_get_volume(volume, afs_volume_trace_get_new_op);
e49c7b2f DH	40	op->net = volume->cell->net;
	41	op->cb_v_break = volume->cb_v_break;
	42	op->debug_id = atomic_inc_return(&afs_operation_debug_counter);
	43	op->error = -EDESTADDRREQ;
	44	op->ac.error = SHRT_MAX;
	45
	46	_leave(" = [op=%08x]", op->debug_id);
	47	return op;
	48	}
	49
	50	/*
	51	* Lock the vnode(s) being operated upon.
	52	*/
	53	static bool afs_get_io_locks(struct afs_operation *op)
	54	{
	55	struct afs_vnode *vnode = op->file[0].vnode;
	56	struct afs_vnode *vnode2 = op->file[1].vnode;
	57
	58	_enter("");
	59
	60	if (op->flags & AFS_OPERATION_UNINTR) {
	61	mutex_lock(&vnode->io_lock);
	62	op->flags \|= AFS_OPERATION_LOCK_0;
	63	_leave(" = t [1]");
	64	return true;
	65	}
	66
	67	if (!vnode2 \|\| !op->file[1].need_io_lock \|\| vnode == vnode2)
	68	vnode2 = NULL;
	69
	70	if (vnode2 > vnode)
	71	swap(vnode, vnode2);
	72
	73	if (mutex_lock_interruptible(&vnode->io_lock) < 0) {
811f04ba	74	op->error = -ERESTARTSYS;
e49c7b2f DH	75	op->flags \|= AFS_OPERATION_STOP;
	76	_leave(" = f [I 0]");
	77	return false;
	78	}
	79	op->flags \|= AFS_OPERATION_LOCK_0;
	80
	81	if (vnode2) {
	82	if (mutex_lock_interruptible_nested(&vnode2->io_lock, 1) < 0) {
811f04ba	83	op->error = -ERESTARTSYS;
e49c7b2f DH	84	op->flags \|= AFS_OPERATION_STOP;
	85	mutex_unlock(&vnode->io_lock);
	86	op->flags &= ~AFS_OPERATION_LOCK_0;
	87	_leave(" = f [I 1]");
	88	return false;
	89	}
	90	op->flags \|= AFS_OPERATION_LOCK_1;
	91	}
	92
	93	_leave(" = t [2]");
	94	return true;
	95	}
	96
	97	static void afs_drop_io_locks(struct afs_operation *op)
	98	{
	99	struct afs_vnode *vnode = op->file[0].vnode;
	100	struct afs_vnode *vnode2 = op->file[1].vnode;
	101
	102	_enter("");
	103
	104	if (op->flags & AFS_OPERATION_LOCK_1)
	105	mutex_unlock(&vnode2->io_lock);
	106	if (op->flags & AFS_OPERATION_LOCK_0)
	107	mutex_unlock(&vnode->io_lock);
	108	}
	109
	110	static void afs_prepare_vnode(struct afs_operation op, struct afs_vnode_param vp,
	111	unsigned int index)
	112	{
	113	struct afs_vnode *vnode = vp->vnode;
	114
	115	if (vnode) {
	116	vp->fid = vnode->fid;
	117	vp->dv_before = vnode->status.data_version;
	118	vp->cb_break_before = afs_calc_vnode_cb_break(vnode);
	119	if (vnode->lock_state != AFS_VNODE_LOCK_NONE)
	120	op->flags \|= AFS_OPERATION_CUR_ONLY;
	121	}
	122
	123	if (vp->fid.vnode)
	124	_debug("PREP[%u] {%llx:%llu.%u}",
	125	index, vp->fid.vid, vp->fid.vnode, vp->fid.unique);
	126	}
	127
	128	/*
	129	* Begin an operation on the fileserver.
	130	*
	131	* Fileserver operations are serialised on the server by vnode, so we serialise
	132	* them here also using the io_lock.
	133	*/
	134	bool afs_begin_vnode_operation(struct afs_operation *op)
	135	{
	136	struct afs_vnode *vnode = op->file[0].vnode;
	137
	138	ASSERT(vnode);
	139
	140	_enter("");
	141
	142	if (op->file[0].need_io_lock)
	143	if (!afs_get_io_locks(op))
	144	return false;
	145
e49c7b2f DH	146	afs_prepare_vnode(op, &op->file[0], 0);
	147	afs_prepare_vnode(op, &op->file[1], 1);
	148	op->cb_v_break = op->volume->cb_v_break;
	149	_leave(" = true");
	150	return true;
	151	}
	152
	153	/*
	154	* Tidy up a filesystem cursor and unlock the vnode.
	155	*/
	156	static void afs_end_vnode_operation(struct afs_operation *op)
	157	{
	158	_enter("");
	159
	160	if (op->error == -EDESTADDRREQ \|\|
	161	op->error == -EADDRNOTAVAIL \|\|
	162	op->error == -ENETUNREACH \|\|
	163	op->error == -EHOSTUNREACH)
	164	afs_dump_edestaddrreq(op);
	165
	166	afs_drop_io_locks(op);
	167
	168	if (op->error == -ECONNABORTED)
	169	op->error = afs_abort_to_error(op->ac.abort_code);
	170	}
	171
	172	/*
	173	* Wait for an in-progress operation to complete.
	174	*/
	175	void afs_wait_for_operation(struct afs_operation *op)
	176	{
	177	_enter("");
	178
	179	while (afs_select_fileserver(op)) {
20325960 DH	180	op->cb_s_break = op->server->cb_s_break;
20325960 DH	181	if (test_bit(AFS_SERVER_FL_IS_YFS, &op->server->flags) &&
e49c7b2f DH	182	op->ops->issue_yfs_rpc)
e49c7b2f DH	183	op->ops->issue_yfs_rpc(op);
c448ea17	184	else if (op->ops->issue_afs_rpc)
e49c7b2f	185	op->ops->issue_afs_rpc(op);
c448ea17 DH	186	else
c448ea17 DH	187	op->ac.error = -ENOTSUPP;
e49c7b2f	188
c448ea17 DH	189	if (op->call)
c448ea17 DH	190	op->error = afs_wait_for_call_to_complete(op->call, &op->ac);
e49c7b2f DH	191	}
e49c7b2f DH	192
728279a5 DH	193	switch (op->error) {
728279a5 DH	194	case 0:
e49c7b2f DH	195	_debug("success");
e49c7b2f DH	196	op->ops->success(op);
728279a5 DH	197	break;
	198	case -ECONNABORTED:
	199	if (op->ops->aborted)
	200	op->ops->aborted(op);
	201	break;
	202	default:
	203	break;
e49c7b2f DH	204	}
	205
	206	afs_end_vnode_operation(op);
	207
	208	if (op->error == 0 && op->ops->edit_dir) {
	209	_debug("edit_dir");
	210	op->ops->edit_dir(op);
	211	}
	212	_leave("");
	213	}
	214
	215	/*
	216	* Dispose of an operation.
	217	*/
	218	int afs_put_operation(struct afs_operation *op)
	219	{
	220	int i, ret = op->error;
	221
	222	_enter("op=%08x,%d", op->debug_id, ret);
	223
	224	if (op->ops && op->ops->put)
	225	op->ops->put(op);
	226	if (op->file[0].put_vnode)
	227	iput(&op->file[0].vnode->vfs_inode);
	228	if (op->file[1].put_vnode)
	229	iput(&op->file[1].vnode->vfs_inode);
	230
	231	if (op->more_files) {
	232	for (i = 0; i < op->nr_files - 2; i++)
	233	if (op->more_files[i].put_vnode)
	234	iput(&op->more_files[i].vnode->vfs_inode);
	235	kfree(op->more_files);
	236	}
	237
	238	afs_end_cursor(&op->ac);
e49c7b2f	239	afs_put_serverlist(op->net, op->server_list);
cca37d45	240	afs_put_volume(op->net, op->volume, afs_volume_trace_put_put_op);
ba8e4207	241	key_put(op->key);
e49c7b2f DH	242	kfree(op);
	243	return ret;
	244	}
	245
	246	int afs_do_sync_operation(struct afs_operation *op)
	247	{
	248	afs_begin_vnode_operation(op);
	249	afs_wait_for_operation(op);
	250	return afs_put_operation(op);
	251	}