[mirror_ubuntu-bionic-kernel.git] / fs / nfs / nfs4session.c

/*
 * fs/nfs/nfs4session.c
 *
 * Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com>
 *
 */
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/printk.h>
#include <linux/slab.h>
#include <linux/sunrpc/sched.h>
#include <linux/sunrpc/bc_xprt.h>
#include <linux/nfs.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
#include <linux/module.h>

#include "nfs4_fs.h"
#include "internal.h"
#include "nfs4session.h"
#include "callback.h"

#define NFSDBG_FACILITY		NFSDBG_STATE

/*
 * nfs4_shrink_slot_table - free retired slots from the slot table
 */
static void nfs4_shrink_slot_table(struct nfs4_slot_table  *tbl, u32 newsize)
{
	struct nfs4_slot **p;
	if (newsize >= tbl->max_slots)
		return;

	p = &tbl->slots;
	while (newsize--)
		p = &(*p)->next;
	while (*p) {
		struct nfs4_slot *slot = *p;

		*p = slot->next;
		kfree(slot);
		tbl->max_slots--;
	}
}

/*
 * nfs4_free_slot - free a slot and efficiently update slot table.
 *
 * freeing a slot is trivially done by clearing its respective bit
 * in the bitmap.
 * If the freed slotid equals highest_used_slotid we want to update it
 * so that the server would be able to size down the slot table if needed,
 * otherwise we know that the highest_used_slotid is still in use.
 * When updating highest_used_slotid there may be "holes" in the bitmap
 * so we need to scan down from highest_used_slotid to 0 looking for the now
 * highest slotid in use.
 * If none found, highest_used_slotid is set to NFS4_NO_SLOT.
 *
 * Must be called while holding tbl->slot_tbl_lock
 */
void nfs4_free_slot(struct nfs4_slot_table *tbl, struct nfs4_slot *slot)
{
	u32 slotid = slot->slot_nr;

	/* clear used bit in bitmap */
	__clear_bit(slotid, tbl->used_slots);

	/* update highest_used_slotid when it is freed */
	if (slotid == tbl->highest_used_slotid) {
		u32 new_max = find_last_bit(tbl->used_slots, slotid);
		if (new_max < slotid)
			tbl->highest_used_slotid = new_max;
		else {
			tbl->highest_used_slotid = NFS4_NO_SLOT;
			nfs4_slot_tbl_drain_complete(tbl);
		}
	}
	dprintk("%s: slotid %u highest_used_slotid %d\n", __func__,
		slotid, tbl->highest_used_slotid);
}

static struct nfs4_slot *nfs4_new_slot(struct nfs4_slot_table  *tbl,
		u32 slotid, u32 seq_init, gfp_t gfp_mask)
{
	struct nfs4_slot *slot;

	slot = kzalloc(sizeof(*slot), gfp_mask);
	if (slot) {
		slot->table = tbl;
		slot->slot_nr = slotid;
		slot->seq_nr = seq_init;
	}
	return slot;
}

static struct nfs4_slot *nfs4_find_or_create_slot(struct nfs4_slot_table  *tbl,
		u32 slotid, u32 seq_init, gfp_t gfp_mask)
{
	struct nfs4_slot **p, *slot;

	p = &tbl->slots;
	for (;;) {
		if (*p == NULL) {
			*p = nfs4_new_slot(tbl, tbl->max_slots,
					seq_init, gfp_mask);
			if (*p == NULL)
				break;
			tbl->max_slots++;
		}
		slot = *p;
		if (slot->slot_nr == slotid)
			return slot;
		p = &slot->next;
	}
	return ERR_PTR(-ENOMEM);
}

/*
 * nfs4_alloc_slot - efficiently look for a free slot
 *
 * nfs4_alloc_slot looks for an unset bit in the used_slots bitmap.
 * If found, we mark the slot as used, update the highest_used_slotid,
 * and respectively set up the sequence operation args.
 *
 * Note: must be called with under the slot_tbl_lock.
 */
struct nfs4_slot *nfs4_alloc_slot(struct nfs4_slot_table *tbl)
{
	struct nfs4_slot *ret = ERR_PTR(-EBUSY);
	u32 slotid;

	dprintk("--> %s used_slots=%04lx highest_used=%u max_slots=%u\n",
		__func__, tbl->used_slots[0], tbl->highest_used_slotid,
		tbl->max_slotid + 1);
	slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slotid + 1);
	if (slotid > tbl->max_slotid)
		goto out;
	ret = nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT);
	if (IS_ERR(ret))
		goto out;
	__set_bit(slotid, tbl->used_slots);
	if (slotid > tbl->highest_used_slotid ||
			tbl->highest_used_slotid == NFS4_NO_SLOT)
		tbl->highest_used_slotid = slotid;
	ret->generation = tbl->generation;

out:
	dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n",
		__func__, tbl->used_slots[0], tbl->highest_used_slotid,
		!IS_ERR(ret) ? ret->slot_nr : -1);
	return ret;
}

static int nfs4_grow_slot_table(struct nfs4_slot_table *tbl,
		 u32 max_reqs, u32 ivalue)
{
	if (max_reqs <= tbl->max_slots)
		return 0;
	if (!IS_ERR(nfs4_find_or_create_slot(tbl, max_reqs - 1, ivalue, GFP_NOFS)))
		return 0;
	return -ENOMEM;
}

static void nfs4_reset_slot_table(struct nfs4_slot_table *tbl,
		u32 server_highest_slotid,
		u32 ivalue)
{
	struct nfs4_slot **p;

	nfs4_shrink_slot_table(tbl, server_highest_slotid + 1);
	p = &tbl->slots;
	while (*p) {
		(*p)->seq_nr = ivalue;
		(*p)->interrupted = 0;
		p = &(*p)->next;
	}
	tbl->highest_used_slotid = NFS4_NO_SLOT;
	tbl->target_highest_slotid = server_highest_slotid;
	tbl->server_highest_slotid = server_highest_slotid;
	tbl->d_target_highest_slotid = 0;
	tbl->d2_target_highest_slotid = 0;
	tbl->max_slotid = server_highest_slotid;
}

/*
 * (re)Initialise a slot table
 */
static int nfs4_realloc_slot_table(struct nfs4_slot_table *tbl,
		u32 max_reqs, u32 ivalue)
{
	int ret;

	dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,
		max_reqs, tbl->max_slots);

	if (max_reqs > NFS4_MAX_SLOT_TABLE)
		max_reqs = NFS4_MAX_SLOT_TABLE;

	ret = nfs4_grow_slot_table(tbl, max_reqs, ivalue);
	if (ret)
		goto out;

	spin_lock(&tbl->slot_tbl_lock);
	nfs4_reset_slot_table(tbl, max_reqs - 1, ivalue);
	spin_unlock(&tbl->slot_tbl_lock);

	dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
		tbl, tbl->slots, tbl->max_slots);
out:
	dprintk("<-- %s: return %d\n", __func__, ret);
	return ret;
}

/* Destroy the slot table */
static void nfs4_destroy_slot_tables(struct nfs4_session *session)
{
	nfs4_shrink_slot_table(&session->fc_slot_table, 0);
	nfs4_shrink_slot_table(&session->bc_slot_table, 0);
}

static bool nfs41_assign_slot(struct rpc_task *task, void *pslot)
{
	struct nfs4_sequence_args *args = task->tk_msg.rpc_argp;
	struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
	struct nfs4_slot *slot = pslot;
	struct nfs4_slot_table *tbl = slot->table;

	if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
		return false;
	slot->generation = tbl->generation;
	args->sa_slot = slot;
	res->sr_timestamp = jiffies;
	res->sr_slot = slot;
	res->sr_status_flags = 0;
	res->sr_status = 1;
	return true;
}

static bool __nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
		struct nfs4_slot *slot)
{
	if (rpc_wake_up_first(&tbl->slot_tbl_waitq, nfs41_assign_slot, slot))
		return true;
	return false;
}

bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
		struct nfs4_slot *slot)
{
	if (slot->slot_nr > tbl->max_slotid)
		return false;
	return __nfs41_wake_and_assign_slot(tbl, slot);
}

static bool nfs41_try_wake_next_slot_table_entry(struct nfs4_slot_table *tbl)
{
	struct nfs4_slot *slot = nfs4_alloc_slot(tbl);
	if (!IS_ERR(slot)) {
		bool ret = __nfs41_wake_and_assign_slot(tbl, slot);
		if (ret)
			return ret;
		nfs4_free_slot(tbl, slot);
	}
	return false;
}

void nfs41_wake_slot_table(struct nfs4_slot_table *tbl)
{
	for (;;) {
		if (!nfs41_try_wake_next_slot_table_entry(tbl))
			break;
	}
}

static void nfs41_set_max_slotid_locked(struct nfs4_slot_table *tbl,
		u32 target_highest_slotid)
{
	u32 max_slotid;

	max_slotid = min(NFS4_MAX_SLOT_TABLE - 1, target_highest_slotid);
	if (max_slotid > tbl->server_highest_slotid)
		max_slotid = tbl->server_highest_slotid;
	if (max_slotid > tbl->target_highest_slotid)
		max_slotid = tbl->target_highest_slotid;
	tbl->max_slotid = max_slotid;
	nfs41_wake_slot_table(tbl);
}

/* Update the client's idea of target_highest_slotid */
static void nfs41_set_target_slotid_locked(struct nfs4_slot_table *tbl,
		u32 target_highest_slotid)
{
	if (tbl->target_highest_slotid == target_highest_slotid)
		return;
	tbl->target_highest_slotid = target_highest_slotid;
	tbl->generation++;
}

void nfs41_set_target_slotid(struct nfs4_slot_table *tbl,
		u32 target_highest_slotid)
{
	spin_lock(&tbl->slot_tbl_lock);
	nfs41_set_target_slotid_locked(tbl, target_highest_slotid);
	tbl->d_target_highest_slotid = 0;
	tbl->d2_target_highest_slotid = 0;
	nfs41_set_max_slotid_locked(tbl, target_highest_slotid);
	spin_unlock(&tbl->slot_tbl_lock);
}

static void nfs41_set_server_slotid_locked(struct nfs4_slot_table *tbl,
		u32 highest_slotid)
{
	if (tbl->server_highest_slotid == highest_slotid)
		return;
	if (tbl->highest_used_slotid > highest_slotid)
		return;
	/* Deallocate slots */
	nfs4_shrink_slot_table(tbl, highest_slotid + 1);
	tbl->server_highest_slotid = highest_slotid;
}

static s32 nfs41_derivative_target_slotid(s32 s1, s32 s2)
{
	s1 -= s2;
	if (s1 == 0)
		return 0;
	if (s1 < 0)
		return (s1 - 1) >> 1;
	return (s1 + 1) >> 1;
}

static int nfs41_sign_s32(s32 s1)
{
	if (s1 > 0)
		return 1;
	if (s1 < 0)
		return -1;
	return 0;
}

static bool nfs41_same_sign_or_zero_s32(s32 s1, s32 s2)
{
	if (!s1 || !s2)
		return true;
	return nfs41_sign_s32(s1) == nfs41_sign_s32(s2);
}

/* Try to eliminate outliers by checking for sharp changes in the
 * derivatives and second derivatives
 */
static bool nfs41_is_outlier_target_slotid(struct nfs4_slot_table *tbl,
		u32 new_target)
{
	s32 d_target, d2_target;
	bool ret = true;

	d_target = nfs41_derivative_target_slotid(new_target,
			tbl->target_highest_slotid);
	d2_target = nfs41_derivative_target_slotid(d_target,
			tbl->d_target_highest_slotid);
	/* Is first derivative same sign? */
	if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid))
		ret = false;
	/* Is second derivative same sign? */
	if (nfs41_same_sign_or_zero_s32(d2_target, tbl->d2_target_highest_slotid))
		ret = false;
	tbl->d_target_highest_slotid = d_target;
	tbl->d2_target_highest_slotid = d2_target;
	return ret;
}

void nfs41_update_target_slotid(struct nfs4_slot_table *tbl,
		struct nfs4_slot *slot,
		struct nfs4_sequence_res *res)
{
	spin_lock(&tbl->slot_tbl_lock);
	if (!nfs41_is_outlier_target_slotid(tbl, res->sr_target_highest_slotid))
		nfs41_set_target_slotid_locked(tbl, res->sr_target_highest_slotid);
	if (tbl->generation == slot->generation)
		nfs41_set_server_slotid_locked(tbl, res->sr_highest_slotid);
	nfs41_set_max_slotid_locked(tbl, res->sr_target_highest_slotid);
	spin_unlock(&tbl->slot_tbl_lock);
}

/*
 * Initialize or reset the forechannel and backchannel tables
 */
int nfs4_setup_session_slot_tables(struct nfs4_session *ses)
{
	struct nfs4_slot_table *tbl;
	int status;

	dprintk("--> %s\n", __func__);
	/* Fore channel */
	tbl = &ses->fc_slot_table;
	tbl->session = ses;
	status = nfs4_realloc_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
	if (status) /* -ENOMEM */
		return status;
	/* Back channel */
	tbl = &ses->bc_slot_table;
	tbl->session = ses;
	status = nfs4_realloc_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
	if (status && tbl->slots == NULL)
		/* Fore and back channel share a connection so get
		 * both slot tables or neither */
		nfs4_destroy_slot_tables(ses);
	return status;
}

struct nfs4_session *nfs4_alloc_session(struct nfs_client *clp)
{
	struct nfs4_session *session;
	struct nfs4_slot_table *tbl;

	session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
	if (!session)
		return NULL;

	tbl = &session->fc_slot_table;
	tbl->highest_used_slotid = NFS4_NO_SLOT;
	spin_lock_init(&tbl->slot_tbl_lock);
	rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table");
	init_completion(&tbl->complete);

	tbl = &session->bc_slot_table;
	tbl->highest_used_slotid = NFS4_NO_SLOT;
	spin_lock_init(&tbl->slot_tbl_lock);
	rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table");
	init_completion(&tbl->complete);

	session->session_state = 1<<NFS4_SESSION_INITING;

	session->clp = clp;
	return session;
}

void nfs4_destroy_session(struct nfs4_session *session)
{
	struct rpc_xprt *xprt;
	struct rpc_cred *cred;

	cred = nfs4_get_exchange_id_cred(session->clp);
	nfs4_proc_destroy_session(session, cred);
	if (cred)
		put_rpccred(cred);

	rcu_read_lock();
	xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt);
	rcu_read_unlock();
	dprintk("%s Destroy backchannel for xprt %p\n",
		__func__, xprt);
	xprt_destroy_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
	nfs4_destroy_slot_tables(session);
	kfree(session);
}

/*
 * With sessions, the client is not marked ready until after a
 * successful EXCHANGE_ID and CREATE_SESSION.
 *
 * Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
 * other versions of NFS can be tried.
 */
static int nfs41_check_session_ready(struct nfs_client *clp)
{
	int ret;
	
	if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
		ret = nfs4_client_recover_expired_lease(clp);
		if (ret)
			return ret;
	}
	if (clp->cl_cons_state < NFS_CS_READY)
		return -EPROTONOSUPPORT;
	smp_rmb();
	return 0;
}

int nfs4_init_session(struct nfs_client *clp)
{
	if (!nfs4_has_session(clp))
		return 0;

	clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state);
	return nfs41_check_session_ready(clp);
}

int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time)
{
	struct nfs4_session *session = clp->cl_session;
	int ret;

	spin_lock(&clp->cl_lock);
	if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) {
		/*
		 * Do not set NFS_CS_CHECK_LEASE_TIME instead set the
		 * DS lease to be equal to the MDS lease.
		 */
		clp->cl_lease_time = lease_time;
		clp->cl_last_renewal = jiffies;
	}
	spin_unlock(&clp->cl_lock);

	ret = nfs41_check_session_ready(clp);
	if (ret)
		return ret;
	/* Test for the DS role */
	if (!is_ds_client(clp))
		return -ENODEV;
	return 0;
}
EXPORT_SYMBOL_GPL(nfs4_init_ds_session);
Commit	Line	Data
73e39aaa TM	1	/*
	2	* fs/nfs/nfs4session.c
	3	*
	4	* Copyright (c) 2012 Trond Myklebust <Trond.Myklebust@netapp.com>
	5	*
	6	*/
	7	#include <linux/kernel.h>
	8	#include <linux/errno.h>
	9	#include <linux/string.h>
	10	#include <linux/printk.h>
	11	#include <linux/slab.h>
	12	#include <linux/sunrpc/sched.h>
	13	#include <linux/sunrpc/bc_xprt.h>
	14	#include <linux/nfs.h>
	15	#include <linux/nfs4.h>
	16	#include <linux/nfs_fs.h>
	17	#include <linux/module.h>
	18
	19	#include "nfs4_fs.h"
	20	#include "internal.h"
	21	#include "nfs4session.h"
	22	#include "callback.h"
	23
	24	#define NFSDBG_FACILITY NFSDBG_STATE
	25
	26	/*
	27	* nfs4_shrink_slot_table - free retired slots from the slot table
	28	*/
	29	static void nfs4_shrink_slot_table(struct nfs4_slot_table *tbl, u32 newsize)
	30	{
	31	struct nfs4_slot **p;
	32	if (newsize >= tbl->max_slots)
	33	return;
	34
	35	p = &tbl->slots;
	36	while (newsize--)
	37	p = &(*p)->next;
	38	while (*p) {
	39	struct nfs4_slot slot = p;
	40
	41	*p = slot->next;
	42	kfree(slot);
	43	tbl->max_slots--;
	44	}
	45	}
	46
	47	/*
	48	* nfs4_free_slot - free a slot and efficiently update slot table.
	49	*
	50	* freeing a slot is trivially done by clearing its respective bit
	51	* in the bitmap.
	52	* If the freed slotid equals highest_used_slotid we want to update it
	53	* so that the server would be able to size down the slot table if needed,
	54	* otherwise we know that the highest_used_slotid is still in use.
	55	* When updating highest_used_slotid there may be "holes" in the bitmap
	56	* so we need to scan down from highest_used_slotid to 0 looking for the now
	57	* highest slotid in use.
	58	* If none found, highest_used_slotid is set to NFS4_NO_SLOT.
	59	*
	60	* Must be called while holding tbl->slot_tbl_lock
	61	*/
	62	void nfs4_free_slot(struct nfs4_slot_table tbl, struct nfs4_slot slot)
	63	{
	64	u32 slotid = slot->slot_nr;
65
66	/* clear used bit in bitmap */
67	__clear_bit(slotid, tbl->used_slots);
68
69	/* update highest_used_slotid when it is freed */
70	if (slotid == tbl->highest_used_slotid) {
71	u32 new_max = find_last_bit(tbl->used_slots, slotid);
72	if (new_max < slotid)
73	tbl->highest_used_slotid = new_max;
74	else {
75	tbl->highest_used_slotid = NFS4_NO_SLOT;
774d5f14	76	nfs4_slot_tbl_drain_complete(tbl);
73e39aaa TM	77	}
	78	}
	79	dprintk("%s: slotid %u highest_used_slotid %d\n", __func__,
	80	slotid, tbl->highest_used_slotid);
	81	}
	82
	83	static struct nfs4_slot nfs4_new_slot(struct nfs4_slot_table tbl,
	84	u32 slotid, u32 seq_init, gfp_t gfp_mask)
	85	{
	86	struct nfs4_slot *slot;
	87
	88	slot = kzalloc(sizeof(*slot), gfp_mask);
	89	if (slot) {
	90	slot->table = tbl;
	91	slot->slot_nr = slotid;
	92	slot->seq_nr = seq_init;
	93	}
	94	return slot;
	95	}
	96
	97	static struct nfs4_slot nfs4_find_or_create_slot(struct nfs4_slot_table tbl,
	98	u32 slotid, u32 seq_init, gfp_t gfp_mask)
	99	{
	100	struct nfs4_slot *p, slot;
	101
	102	p = &tbl->slots;
	103	for (;;) {
	104	if (*p == NULL) {
	105	*p = nfs4_new_slot(tbl, tbl->max_slots,
	106	seq_init, gfp_mask);
	107	if (*p == NULL)
	108	break;
	109	tbl->max_slots++;
	110	}
	111	slot = *p;
	112	if (slot->slot_nr == slotid)
	113	return slot;
	114	p = &slot->next;
	115	}
	116	return ERR_PTR(-ENOMEM);
	117	}
	118
	119	/*
	120	* nfs4_alloc_slot - efficiently look for a free slot
	121	*
	122	* nfs4_alloc_slot looks for an unset bit in the used_slots bitmap.
	123	* If found, we mark the slot as used, update the highest_used_slotid,
	124	* and respectively set up the sequence operation args.
	125	*
	126	* Note: must be called with under the slot_tbl_lock.
	127	*/
	128	struct nfs4_slot nfs4_alloc_slot(struct nfs4_slot_table tbl)
	129	{
	130	struct nfs4_slot *ret = ERR_PTR(-EBUSY);
	131	u32 slotid;
	132
	133	dprintk("--> %s used_slots=%04lx highest_used=%u max_slots=%u\n",
	134	__func__, tbl->used_slots[0], tbl->highest_used_slotid,
	135	tbl->max_slotid + 1);
	136	slotid = find_first_zero_bit(tbl->used_slots, tbl->max_slotid + 1);
	137	if (slotid > tbl->max_slotid)
	138	goto out;
	139	ret = nfs4_find_or_create_slot(tbl, slotid, 1, GFP_NOWAIT);
	140	if (IS_ERR(ret))
141	goto out;
142	__set_bit(slotid, tbl->used_slots);
143	if (slotid > tbl->highest_used_slotid \|\|
144	tbl->highest_used_slotid == NFS4_NO_SLOT)
145	tbl->highest_used_slotid = slotid;
73e39aaa TM	146	ret->generation = tbl->generation;
	147
	148	out:
	149	dprintk("<-- %s used_slots=%04lx highest_used=%d slotid=%d \n",
	150	__func__, tbl->used_slots[0], tbl->highest_used_slotid,
	151	!IS_ERR(ret) ? ret->slot_nr : -1);
	152	return ret;
	153	}
	154
	155	static int nfs4_grow_slot_table(struct nfs4_slot_table *tbl,
	156	u32 max_reqs, u32 ivalue)
	157	{
	158	if (max_reqs <= tbl->max_slots)
	159	return 0;
	160	if (!IS_ERR(nfs4_find_or_create_slot(tbl, max_reqs - 1, ivalue, GFP_NOFS)))
	161	return 0;
	162	return -ENOMEM;
	163	}
	164
	165	static void nfs4_reset_slot_table(struct nfs4_slot_table *tbl,
	166	u32 server_highest_slotid,
	167	u32 ivalue)
	168	{
	169	struct nfs4_slot **p;
	170
	171	nfs4_shrink_slot_table(tbl, server_highest_slotid + 1);
	172	p = &tbl->slots;
	173	while (*p) {
	174	(*p)->seq_nr = ivalue;
ac20d163	175	(*p)->interrupted = 0;
73e39aaa TM	176	p = &(*p)->next;
	177	}
	178	tbl->highest_used_slotid = NFS4_NO_SLOT;
	179	tbl->target_highest_slotid = server_highest_slotid;
	180	tbl->server_highest_slotid = server_highest_slotid;
1fa80644 TM	181	tbl->d_target_highest_slotid = 0;
1fa80644 TM	182	tbl->d2_target_highest_slotid = 0;
73e39aaa TM	183	tbl->max_slotid = server_highest_slotid;
	184	}
	185
	186	/*
	187	* (re)Initialise a slot table
	188	*/
	189	static int nfs4_realloc_slot_table(struct nfs4_slot_table *tbl,
	190	u32 max_reqs, u32 ivalue)
	191	{
	192	int ret;
	193
	194	dprintk("--> %s: max_reqs=%u, tbl->max_slots %d\n", __func__,
	195	max_reqs, tbl->max_slots);
	196
	197	if (max_reqs > NFS4_MAX_SLOT_TABLE)
	198	max_reqs = NFS4_MAX_SLOT_TABLE;
	199
	200	ret = nfs4_grow_slot_table(tbl, max_reqs, ivalue);
	201	if (ret)
	202	goto out;
	203
	204	spin_lock(&tbl->slot_tbl_lock);
	205	nfs4_reset_slot_table(tbl, max_reqs - 1, ivalue);
	206	spin_unlock(&tbl->slot_tbl_lock);
	207
	208	dprintk("%s: tbl=%p slots=%p max_slots=%d\n", __func__,
	209	tbl, tbl->slots, tbl->max_slots);
	210	out:
	211	dprintk("<-- %s: return %d\n", __func__, ret);
	212	return ret;
	213	}
	214
	215	/* Destroy the slot table */
	216	static void nfs4_destroy_slot_tables(struct nfs4_session *session)
	217	{
	218	nfs4_shrink_slot_table(&session->fc_slot_table, 0);
	219	nfs4_shrink_slot_table(&session->bc_slot_table, 0);
	220	}
	221
b75ad4cd TM	222	static bool nfs41_assign_slot(struct rpc_task task, void pslot)
	223	{
	224	struct nfs4_sequence_args *args = task->tk_msg.rpc_argp;
	225	struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;
	226	struct nfs4_slot *slot = pslot;
	227	struct nfs4_slot_table *tbl = slot->table;
	228
774d5f14	229	if (nfs4_slot_tbl_draining(tbl) && !args->sa_privileged)
b75ad4cd	230	return false;
b75ad4cd TM	231	slot->generation = tbl->generation;
b75ad4cd TM	232	args->sa_slot = slot;
8e63b6a8	233	res->sr_timestamp = jiffies;
b75ad4cd TM	234	res->sr_slot = slot;
	235	res->sr_status_flags = 0;
	236	res->sr_status = 1;
	237	return true;
	238	}
	239
	240	static bool __nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
	241	struct nfs4_slot *slot)
	242	{
	243	if (rpc_wake_up_first(&tbl->slot_tbl_waitq, nfs41_assign_slot, slot))
	244	return true;
	245	return false;
	246	}
	247
	248	bool nfs41_wake_and_assign_slot(struct nfs4_slot_table *tbl,
	249	struct nfs4_slot *slot)
	250	{
	251	if (slot->slot_nr > tbl->max_slotid)
	252	return false;
	253	return __nfs41_wake_and_assign_slot(tbl, slot);
	254	}
	255
	256	static bool nfs41_try_wake_next_slot_table_entry(struct nfs4_slot_table *tbl)
	257	{
	258	struct nfs4_slot *slot = nfs4_alloc_slot(tbl);
	259	if (!IS_ERR(slot)) {
	260	bool ret = __nfs41_wake_and_assign_slot(tbl, slot);
	261	if (ret)
	262	return ret;
	263	nfs4_free_slot(tbl, slot);
	264	}
	265	return false;
	266	}
	267
	268	void nfs41_wake_slot_table(struct nfs4_slot_table *tbl)
	269	{
	270	for (;;) {
	271	if (!nfs41_try_wake_next_slot_table_entry(tbl))
	272	break;
	273	}
	274	}
	275
b0ef9647 TM	276	static void nfs41_set_max_slotid_locked(struct nfs4_slot_table *tbl,
	277	u32 target_highest_slotid)
	278	{
	279	u32 max_slotid;
	280
	281	max_slotid = min(NFS4_MAX_SLOT_TABLE - 1, target_highest_slotid);
	282	if (max_slotid > tbl->server_highest_slotid)
	283	max_slotid = tbl->server_highest_slotid;
	284	if (max_slotid > tbl->target_highest_slotid)
	285	max_slotid = tbl->target_highest_slotid;
	286	tbl->max_slotid = max_slotid;
	287	nfs41_wake_slot_table(tbl);
	288	}
	289
73e39aaa TM	290	/* Update the client's idea of target_highest_slotid */
	291	static void nfs41_set_target_slotid_locked(struct nfs4_slot_table *tbl,
	292	u32 target_highest_slotid)
	293	{
73e39aaa TM	294	if (tbl->target_highest_slotid == target_highest_slotid)
	295	return;
	296	tbl->target_highest_slotid = target_highest_slotid;
	297	tbl->generation++;
73e39aaa TM	298	}
	299
	300	void nfs41_set_target_slotid(struct nfs4_slot_table *tbl,
	301	u32 target_highest_slotid)
	302	{
	303	spin_lock(&tbl->slot_tbl_lock);
	304	nfs41_set_target_slotid_locked(tbl, target_highest_slotid);
1fa80644 TM	305	tbl->d_target_highest_slotid = 0;
1fa80644 TM	306	tbl->d2_target_highest_slotid = 0;
b0ef9647	307	nfs41_set_max_slotid_locked(tbl, target_highest_slotid);
73e39aaa TM	308	spin_unlock(&tbl->slot_tbl_lock);
	309	}
	310
	311	static void nfs41_set_server_slotid_locked(struct nfs4_slot_table *tbl,
	312	u32 highest_slotid)
	313	{
	314	if (tbl->server_highest_slotid == highest_slotid)
	315	return;
	316	if (tbl->highest_used_slotid > highest_slotid)
	317	return;
	318	/* Deallocate slots */
	319	nfs4_shrink_slot_table(tbl, highest_slotid + 1);
	320	tbl->server_highest_slotid = highest_slotid;
	321	}
	322
1fa80644 TM	323	static s32 nfs41_derivative_target_slotid(s32 s1, s32 s2)
	324	{
	325	s1 -= s2;
	326	if (s1 == 0)
	327	return 0;
	328	if (s1 < 0)
	329	return (s1 - 1) >> 1;
	330	return (s1 + 1) >> 1;
	331	}
	332
	333	static int nfs41_sign_s32(s32 s1)
	334	{
	335	if (s1 > 0)
	336	return 1;
	337	if (s1 < 0)
	338	return -1;
	339	return 0;
	340	}
	341
	342	static bool nfs41_same_sign_or_zero_s32(s32 s1, s32 s2)
	343	{
	344	if (!s1 \|\| !s2)
	345	return true;
	346	return nfs41_sign_s32(s1) == nfs41_sign_s32(s2);
	347	}
	348
	349	/* Try to eliminate outliers by checking for sharp changes in the
	350	* derivatives and second derivatives
	351	*/
	352	static bool nfs41_is_outlier_target_slotid(struct nfs4_slot_table *tbl,
	353	u32 new_target)
	354	{
	355	s32 d_target, d2_target;
	356	bool ret = true;
	357
	358	d_target = nfs41_derivative_target_slotid(new_target,
	359	tbl->target_highest_slotid);
	360	d2_target = nfs41_derivative_target_slotid(d_target,
	361	tbl->d_target_highest_slotid);
	362	/* Is first derivative same sign? */
	363	if (nfs41_same_sign_or_zero_s32(d_target, tbl->d_target_highest_slotid))
	364	ret = false;
	365	/* Is second derivative same sign? */
	366	if (nfs41_same_sign_or_zero_s32(d2_target, tbl->d2_target_highest_slotid))
	367	ret = false;
	368	tbl->d_target_highest_slotid = d_target;
	369	tbl->d2_target_highest_slotid = d2_target;
	370	return ret;
	371	}
	372
73e39aaa TM	373	void nfs41_update_target_slotid(struct nfs4_slot_table *tbl,
	374	struct nfs4_slot *slot,
	375	struct nfs4_sequence_res *res)
	376	{
	377	spin_lock(&tbl->slot_tbl_lock);
1fa80644 TM	378	if (!nfs41_is_outlier_target_slotid(tbl, res->sr_target_highest_slotid))
	379	nfs41_set_target_slotid_locked(tbl, res->sr_target_highest_slotid);
	380	if (tbl->generation == slot->generation)
	381	nfs41_set_server_slotid_locked(tbl, res->sr_highest_slotid);
b0ef9647	382	nfs41_set_max_slotid_locked(tbl, res->sr_target_highest_slotid);
73e39aaa TM	383	spin_unlock(&tbl->slot_tbl_lock);
	384	}
	385
	386	/*
	387	* Initialize or reset the forechannel and backchannel tables
	388	*/
	389	int nfs4_setup_session_slot_tables(struct nfs4_session *ses)
	390	{
	391	struct nfs4_slot_table *tbl;
	392	int status;
	393
	394	dprintk("--> %s\n", __func__);
	395	/* Fore channel */
	396	tbl = &ses->fc_slot_table;
	397	tbl->session = ses;
	398	status = nfs4_realloc_slot_table(tbl, ses->fc_attrs.max_reqs, 1);
	399	if (status) /* -ENOMEM */
	400	return status;
	401	/* Back channel */
	402	tbl = &ses->bc_slot_table;
	403	tbl->session = ses;
	404	status = nfs4_realloc_slot_table(tbl, ses->bc_attrs.max_reqs, 0);
	405	if (status && tbl->slots == NULL)
	406	/* Fore and back channel share a connection so get
	407	* both slot tables or neither */
	408	nfs4_destroy_slot_tables(ses);
	409	return status;
	410	}
	411
	412	struct nfs4_session nfs4_alloc_session(struct nfs_client clp)
	413	{
	414	struct nfs4_session *session;
	415	struct nfs4_slot_table *tbl;
	416
	417	session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
	418	if (!session)
	419	return NULL;
	420
	421	tbl = &session->fc_slot_table;
	422	tbl->highest_used_slotid = NFS4_NO_SLOT;
	423	spin_lock_init(&tbl->slot_tbl_lock);
	424	rpc_init_priority_wait_queue(&tbl->slot_tbl_waitq, "ForeChannel Slot table");
	425	init_completion(&tbl->complete);
	426
	427	tbl = &session->bc_slot_table;
	428	tbl->highest_used_slotid = NFS4_NO_SLOT;
	429	spin_lock_init(&tbl->slot_tbl_lock);
	430	rpc_init_wait_queue(&tbl->slot_tbl_waitq, "BackChannel Slot table");
	431	init_completion(&tbl->complete);
	432
	433	session->session_state = 1<<NFS4_SESSION_INITING;
	434
	435	session->clp = clp;
	436	return session;
	437	}
	438
	439	void nfs4_destroy_session(struct nfs4_session *session)
	440	{
	441	struct rpc_xprt *xprt;
	442	struct rpc_cred *cred;
	443
	444	cred = nfs4_get_exchange_id_cred(session->clp);
	445	nfs4_proc_destroy_session(session, cred);
	446	if (cred)
447	put_rpccred(cred);
448
449	rcu_read_lock();
450	xprt = rcu_dereference(session->clp->cl_rpcclient->cl_xprt);
451	rcu_read_unlock();
452	dprintk("%s Destroy backchannel for xprt %p\n",
453	__func__, xprt);
454	xprt_destroy_backchannel(xprt, NFS41_BC_MIN_CALLBACKS);
455	nfs4_destroy_slot_tables(session);
456	kfree(session);
457	}
458
459	/*
460	* With sessions, the client is not marked ready until after a
461	* successful EXCHANGE_ID and CREATE_SESSION.
462	*
463	* Map errors cl_cons_state errors to EPROTONOSUPPORT to indicate
464	* other versions of NFS can be tried.
465	*/
466	static int nfs41_check_session_ready(struct nfs_client *clp)
467	{
468	int ret;
469
470	if (clp->cl_cons_state == NFS_CS_SESSION_INITING) {
471	ret = nfs4_client_recover_expired_lease(clp);
472	if (ret)
473	return ret;
474	}
475	if (clp->cl_cons_state < NFS_CS_READY)
476	return -EPROTONOSUPPORT;
477	smp_rmb();
478	return 0;
479	}
480
18aad3d5	481	int nfs4_init_session(struct nfs_client *clp)
73e39aaa	482	{
73e39aaa TM	483	if (!nfs4_has_session(clp))
	484	return 0;
	485
18aad3d5	486	clear_bit(NFS4_SESSION_INITING, &clp->cl_session->session_state);
73e39aaa TM	487	return nfs41_check_session_ready(clp);
	488	}
	489
	490	int nfs4_init_ds_session(struct nfs_client *clp, unsigned long lease_time)
	491	{
	492	struct nfs4_session *session = clp->cl_session;
	493	int ret;
	494
	495	spin_lock(&clp->cl_lock);
	496	if (test_and_clear_bit(NFS4_SESSION_INITING, &session->session_state)) {
	497	/*
	498	* Do not set NFS_CS_CHECK_LEASE_TIME instead set the
	499	* DS lease to be equal to the MDS lease.
	500	*/
	501	clp->cl_lease_time = lease_time;
	502	clp->cl_last_renewal = jiffies;
	503	}
	504	spin_unlock(&clp->cl_lock);
	505
	506	ret = nfs41_check_session_ready(clp);
	507	if (ret)
	508	return ret;
	509	/* Test for the DS role */
	510	if (!is_ds_client(clp))
	511	return -ENODEV;
	512	return 0;
	513	}
	514	EXPORT_SYMBOL_GPL(nfs4_init_ds_session);
	515
	516