[deliverable/linux.git] / drivers / target / iscsi / iscsi_target_tq.c

/*******************************************************************************
 * This file contains the iSCSI Login Thread and Thread Queue functions.
 *
 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
 *
 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
 *
 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 ******************************************************************************/

#include <linux/kthread.h>
#include <linux/list.h>
#include <linux/bitmap.h>

#include "iscsi_target_core.h"
#include "iscsi_target_tq.h"
#include "iscsi_target.h"

static LIST_HEAD(active_ts_list);
static LIST_HEAD(inactive_ts_list);
static DEFINE_SPINLOCK(active_ts_lock);
static DEFINE_SPINLOCK(inactive_ts_lock);
static DEFINE_SPINLOCK(ts_bitmap_lock);

static void iscsi_add_ts_to_active_list(struct iscsi_thread_set *ts)
{
	spin_lock(&active_ts_lock);
	list_add_tail(&ts->ts_list, &active_ts_list);
	iscsit_global->active_ts++;
	spin_unlock(&active_ts_lock);
}

extern void iscsi_add_ts_to_inactive_list(struct iscsi_thread_set *ts)
{
	spin_lock(&inactive_ts_lock);
	list_add_tail(&ts->ts_list, &inactive_ts_list);
	iscsit_global->inactive_ts++;
	spin_unlock(&inactive_ts_lock);
}

static void iscsi_del_ts_from_active_list(struct iscsi_thread_set *ts)
{
	spin_lock(&active_ts_lock);
	list_del(&ts->ts_list);
	iscsit_global->active_ts--;
	spin_unlock(&active_ts_lock);
}

static struct iscsi_thread_set *iscsi_get_ts_from_inactive_list(void)
{
	struct iscsi_thread_set *ts;

	spin_lock(&inactive_ts_lock);
	if (list_empty(&inactive_ts_list)) {
		spin_unlock(&inactive_ts_lock);
		return NULL;
	}

	list_for_each_entry(ts, &inactive_ts_list, ts_list)
		break;

	list_del(&ts->ts_list);
	iscsit_global->inactive_ts--;
	spin_unlock(&inactive_ts_lock);

	return ts;
}

extern int iscsi_allocate_thread_sets(u32 thread_pair_count)
{
	int allocated_thread_pair_count = 0, i, thread_id;
	struct iscsi_thread_set *ts = NULL;

	for (i = 0; i < thread_pair_count; i++) {
		ts = kzalloc(sizeof(struct iscsi_thread_set), GFP_KERNEL);
		if (!ts) {
			pr_err("Unable to allocate memory for"
					" thread set.\n");
			return allocated_thread_pair_count;
		}
		/*
		 * Locate the next available regision in the thread_set_bitmap
		 */
		spin_lock(&ts_bitmap_lock);
		thread_id = bitmap_find_free_region(iscsit_global->ts_bitmap,
				iscsit_global->ts_bitmap_count, get_order(1));
		spin_unlock(&ts_bitmap_lock);
		if (thread_id < 0) {
			pr_err("bitmap_find_free_region() failed for"
				" thread_set_bitmap\n");
			kfree(ts);
			return allocated_thread_pair_count;
		}

		ts->thread_id = thread_id;
		ts->status = ISCSI_THREAD_SET_FREE;
		INIT_LIST_HEAD(&ts->ts_list);
		spin_lock_init(&ts->ts_state_lock);
		init_completion(&ts->rx_post_start_comp);
		init_completion(&ts->tx_post_start_comp);
		init_completion(&ts->rx_restart_comp);
		init_completion(&ts->tx_restart_comp);
		init_completion(&ts->rx_start_comp);
		init_completion(&ts->tx_start_comp);

		ts->create_threads = 1;
		ts->tx_thread = kthread_run(iscsi_target_tx_thread, ts, "%s",
					ISCSI_TX_THREAD_NAME);
		if (IS_ERR(ts->tx_thread)) {
			dump_stack();
			pr_err("Unable to start iscsi_target_tx_thread\n");
			break;
		}

		ts->rx_thread = kthread_run(iscsi_target_rx_thread, ts, "%s",
					ISCSI_RX_THREAD_NAME);
		if (IS_ERR(ts->rx_thread)) {
			kthread_stop(ts->tx_thread);
			pr_err("Unable to start iscsi_target_rx_thread\n");
			break;
		}
		ts->create_threads = 0;

		iscsi_add_ts_to_inactive_list(ts);
		allocated_thread_pair_count++;
	}

	pr_debug("Spawned %d thread set(s) (%d total threads).\n",
		allocated_thread_pair_count, allocated_thread_pair_count * 2);
	return allocated_thread_pair_count;
}

extern void iscsi_deallocate_thread_sets(void)
{
	u32 released_count = 0;
	struct iscsi_thread_set *ts = NULL;

	while ((ts = iscsi_get_ts_from_inactive_list())) {

		spin_lock_bh(&ts->ts_state_lock);
		ts->status = ISCSI_THREAD_SET_DIE;
		spin_unlock_bh(&ts->ts_state_lock);

		if (ts->rx_thread) {
			send_sig(SIGINT, ts->rx_thread, 1);
			kthread_stop(ts->rx_thread);
		}
		if (ts->tx_thread) {
			send_sig(SIGINT, ts->tx_thread, 1);
			kthread_stop(ts->tx_thread);
		}
		/*
		 * Release this thread_id in the thread_set_bitmap
		 */
		spin_lock(&ts_bitmap_lock);
		bitmap_release_region(iscsit_global->ts_bitmap,
				ts->thread_id, get_order(1));
		spin_unlock(&ts_bitmap_lock);

		released_count++;
		kfree(ts);
	}

	if (released_count)
		pr_debug("Stopped %d thread set(s) (%d total threads)."
			"\n", released_count, released_count * 2);
}

static void iscsi_deallocate_extra_thread_sets(void)
{
	u32 orig_count, released_count = 0;
	struct iscsi_thread_set *ts = NULL;

	orig_count = TARGET_THREAD_SET_COUNT;

	while ((iscsit_global->inactive_ts + 1) > orig_count) {
		ts = iscsi_get_ts_from_inactive_list();
		if (!ts)
			break;

		spin_lock_bh(&ts->ts_state_lock);
		ts->status = ISCSI_THREAD_SET_DIE;
		spin_unlock_bh(&ts->ts_state_lock);

		if (ts->rx_thread) {
			send_sig(SIGINT, ts->rx_thread, 1);
			kthread_stop(ts->rx_thread);
		}
		if (ts->tx_thread) {
			send_sig(SIGINT, ts->tx_thread, 1);
			kthread_stop(ts->tx_thread);
		}
		/*
		 * Release this thread_id in the thread_set_bitmap
		 */
		spin_lock(&ts_bitmap_lock);
		bitmap_release_region(iscsit_global->ts_bitmap,
				ts->thread_id, get_order(1));
		spin_unlock(&ts_bitmap_lock);

		released_count++;
		kfree(ts);
	}

	if (released_count) {
		pr_debug("Stopped %d thread set(s) (%d total threads)."
			"\n", released_count, released_count * 2);
	}
}

void iscsi_activate_thread_set(struct iscsi_conn *conn, struct iscsi_thread_set *ts)
{
	iscsi_add_ts_to_active_list(ts);

	spin_lock_bh(&ts->ts_state_lock);
	conn->thread_set = ts;
	ts->conn = conn;
	spin_unlock_bh(&ts->ts_state_lock);
	/*
	 * Start up the RX thread and wait on rx_post_start_comp.  The RX
	 * Thread will then do the same for the TX Thread in
	 * iscsi_rx_thread_pre_handler().
	 */
	complete(&ts->rx_start_comp);
	wait_for_completion(&ts->rx_post_start_comp);
}

struct iscsi_thread_set *iscsi_get_thread_set(void)
{
	int allocate_ts = 0;
	struct completion comp;
	struct iscsi_thread_set *ts = NULL;
	/*
	 * If no inactive thread set is available on the first call to
	 * iscsi_get_ts_from_inactive_list(), sleep for a second and
	 * try again.  If still none are available after two attempts,
	 * allocate a set ourselves.
	 */
get_set:
	ts = iscsi_get_ts_from_inactive_list();
	if (!ts) {
		if (allocate_ts == 2)
			iscsi_allocate_thread_sets(1);

		init_completion(&comp);
		wait_for_completion_timeout(&comp, 1 * HZ);

		allocate_ts++;
		goto get_set;
	}

	ts->delay_inactive = 1;
	ts->signal_sent = 0;
	ts->thread_count = 2;
	init_completion(&ts->rx_restart_comp);
	init_completion(&ts->tx_restart_comp);

	return ts;
}

void iscsi_set_thread_clear(struct iscsi_conn *conn, u8 thread_clear)
{
	struct iscsi_thread_set *ts = NULL;

	if (!conn->thread_set) {
		pr_err("struct iscsi_conn->thread_set is NULL\n");
		return;
	}
	ts = conn->thread_set;

	spin_lock_bh(&ts->ts_state_lock);
	ts->thread_clear &= ~thread_clear;

	if ((thread_clear & ISCSI_CLEAR_RX_THREAD) &&
	    (ts->blocked_threads & ISCSI_BLOCK_RX_THREAD))
		complete(&ts->rx_restart_comp);
	else if ((thread_clear & ISCSI_CLEAR_TX_THREAD) &&
		 (ts->blocked_threads & ISCSI_BLOCK_TX_THREAD))
		complete(&ts->tx_restart_comp);
	spin_unlock_bh(&ts->ts_state_lock);
}

void iscsi_set_thread_set_signal(struct iscsi_conn *conn, u8 signal_sent)
{
	struct iscsi_thread_set *ts = NULL;

	if (!conn->thread_set) {
		pr_err("struct iscsi_conn->thread_set is NULL\n");
		return;
	}
	ts = conn->thread_set;

	spin_lock_bh(&ts->ts_state_lock);
	ts->signal_sent |= signal_sent;
	spin_unlock_bh(&ts->ts_state_lock);
}

int iscsi_release_thread_set(struct iscsi_conn *conn)
{
	int thread_called = 0;
	struct iscsi_thread_set *ts = NULL;

	if (!conn || !conn->thread_set) {
		pr_err("connection or thread set pointer is NULL\n");
		BUG();
	}
	ts = conn->thread_set;

	spin_lock_bh(&ts->ts_state_lock);
	ts->status = ISCSI_THREAD_SET_RESET;

	if (!strncmp(current->comm, ISCSI_RX_THREAD_NAME,
			strlen(ISCSI_RX_THREAD_NAME)))
		thread_called = ISCSI_RX_THREAD;
	else if (!strncmp(current->comm, ISCSI_TX_THREAD_NAME,
			strlen(ISCSI_TX_THREAD_NAME)))
		thread_called = ISCSI_TX_THREAD;

	if (ts->rx_thread && (thread_called == ISCSI_TX_THREAD) &&
	   (ts->thread_clear & ISCSI_CLEAR_RX_THREAD)) {

		if (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD)) {
			send_sig(SIGINT, ts->rx_thread, 1);
			ts->signal_sent |= ISCSI_SIGNAL_RX_THREAD;
		}
		ts->blocked_threads |= ISCSI_BLOCK_RX_THREAD;
		spin_unlock_bh(&ts->ts_state_lock);
		wait_for_completion(&ts->rx_restart_comp);
		spin_lock_bh(&ts->ts_state_lock);
		ts->blocked_threads &= ~ISCSI_BLOCK_RX_THREAD;
	}
	if (ts->tx_thread && (thread_called == ISCSI_RX_THREAD) &&
	   (ts->thread_clear & ISCSI_CLEAR_TX_THREAD)) {

		if (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD)) {
			send_sig(SIGINT, ts->tx_thread, 1);
			ts->signal_sent |= ISCSI_SIGNAL_TX_THREAD;
		}
		ts->blocked_threads |= ISCSI_BLOCK_TX_THREAD;
		spin_unlock_bh(&ts->ts_state_lock);
		wait_for_completion(&ts->tx_restart_comp);
		spin_lock_bh(&ts->ts_state_lock);
		ts->blocked_threads &= ~ISCSI_BLOCK_TX_THREAD;
	}

	ts->conn = NULL;
	ts->status = ISCSI_THREAD_SET_FREE;
	spin_unlock_bh(&ts->ts_state_lock);

	return 0;
}

int iscsi_thread_set_force_reinstatement(struct iscsi_conn *conn)
{
	struct iscsi_thread_set *ts;

	if (!conn->thread_set)
		return -1;
	ts = conn->thread_set;

	spin_lock_bh(&ts->ts_state_lock);
	if (ts->status != ISCSI_THREAD_SET_ACTIVE) {
		spin_unlock_bh(&ts->ts_state_lock);
		return -1;
	}

	if (ts->tx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD))) {
		send_sig(SIGINT, ts->tx_thread, 1);
		ts->signal_sent |= ISCSI_SIGNAL_TX_THREAD;
	}
	if (ts->rx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD))) {
		send_sig(SIGINT, ts->rx_thread, 1);
		ts->signal_sent |= ISCSI_SIGNAL_RX_THREAD;
	}
	spin_unlock_bh(&ts->ts_state_lock);

	return 0;
}

static void iscsi_check_to_add_additional_sets(void)
{
	int thread_sets_add;

	spin_lock(&inactive_ts_lock);
	thread_sets_add = iscsit_global->inactive_ts;
	spin_unlock(&inactive_ts_lock);
	if (thread_sets_add == 1)
		iscsi_allocate_thread_sets(1);
}

static int iscsi_signal_thread_pre_handler(struct iscsi_thread_set *ts)
{
	spin_lock_bh(&ts->ts_state_lock);
	if ((ts->status == ISCSI_THREAD_SET_DIE) || signal_pending(current)) {
		spin_unlock_bh(&ts->ts_state_lock);
		return -1;
	}
	spin_unlock_bh(&ts->ts_state_lock);

	return 0;
}

struct iscsi_conn *iscsi_rx_thread_pre_handler(struct iscsi_thread_set *ts)
{
	int ret;

	spin_lock_bh(&ts->ts_state_lock);
	if (ts->create_threads) {
		spin_unlock_bh(&ts->ts_state_lock);
		goto sleep;
	}

	flush_signals(current);

	if (ts->delay_inactive && (--ts->thread_count == 0)) {
		spin_unlock_bh(&ts->ts_state_lock);
		iscsi_del_ts_from_active_list(ts);

		if (!iscsit_global->in_shutdown)
			iscsi_deallocate_extra_thread_sets();

		iscsi_add_ts_to_inactive_list(ts);
		spin_lock_bh(&ts->ts_state_lock);
	}

	if ((ts->status == ISCSI_THREAD_SET_RESET) &&
	    (ts->thread_clear & ISCSI_CLEAR_RX_THREAD))
		complete(&ts->rx_restart_comp);

	ts->thread_clear &= ~ISCSI_CLEAR_RX_THREAD;
	spin_unlock_bh(&ts->ts_state_lock);
sleep:
	ret = wait_for_completion_interruptible(&ts->rx_start_comp);
	if (ret != 0)
		return NULL;

	if (iscsi_signal_thread_pre_handler(ts) < 0)
		return NULL;

	if (!ts->conn) {
		pr_err("struct iscsi_thread_set->conn is NULL for"
			" thread_id: %d, going back to sleep\n", ts->thread_id);
		goto sleep;
	}
	iscsi_check_to_add_additional_sets();
	/*
	 * The RX Thread starts up the TX Thread and sleeps.
	 */
	ts->thread_clear |= ISCSI_CLEAR_RX_THREAD;
	complete(&ts->tx_start_comp);
	wait_for_completion(&ts->tx_post_start_comp);

	return ts->conn;
}

struct iscsi_conn *iscsi_tx_thread_pre_handler(struct iscsi_thread_set *ts)
{
	int ret;

	spin_lock_bh(&ts->ts_state_lock);
	if (ts->create_threads) {
		spin_unlock_bh(&ts->ts_state_lock);
		goto sleep;
	}

	flush_signals(current);

	if (ts->delay_inactive && (--ts->thread_count == 0)) {
		spin_unlock_bh(&ts->ts_state_lock);
		iscsi_del_ts_from_active_list(ts);

		if (!iscsit_global->in_shutdown)
			iscsi_deallocate_extra_thread_sets();

		iscsi_add_ts_to_inactive_list(ts);
		spin_lock_bh(&ts->ts_state_lock);
	}
	if ((ts->status == ISCSI_THREAD_SET_RESET) &&
	    (ts->thread_clear & ISCSI_CLEAR_TX_THREAD))
		complete(&ts->tx_restart_comp);

	ts->thread_clear &= ~ISCSI_CLEAR_TX_THREAD;
	spin_unlock_bh(&ts->ts_state_lock);
sleep:
	ret = wait_for_completion_interruptible(&ts->tx_start_comp);
	if (ret != 0)
		return NULL;

	if (iscsi_signal_thread_pre_handler(ts) < 0)
		return NULL;

	if (!ts->conn) {
		pr_err("struct iscsi_thread_set->conn is NULL for "
			" thread_id: %d, going back to sleep\n",
			ts->thread_id);
		goto sleep;
	}

	iscsi_check_to_add_additional_sets();
	/*
	 * From the TX thread, up the tx_post_start_comp that the RX Thread is
	 * sleeping on in iscsi_rx_thread_pre_handler(), then up the
	 * rx_post_start_comp that iscsi_activate_thread_set() is sleeping on.
	 */
	ts->thread_clear |= ISCSI_CLEAR_TX_THREAD;
	complete(&ts->tx_post_start_comp);
	complete(&ts->rx_post_start_comp);

	spin_lock_bh(&ts->ts_state_lock);
	ts->status = ISCSI_THREAD_SET_ACTIVE;
	spin_unlock_bh(&ts->ts_state_lock);

	return ts->conn;
}

int iscsi_thread_set_init(void)
{
	int size;

	iscsit_global->ts_bitmap_count = ISCSI_TS_BITMAP_BITS;

	size = BITS_TO_LONGS(iscsit_global->ts_bitmap_count) * sizeof(long);
	iscsit_global->ts_bitmap = kzalloc(size, GFP_KERNEL);
	if (!iscsit_global->ts_bitmap) {
		pr_err("Unable to allocate iscsit_global->ts_bitmap\n");
		return -ENOMEM;
	}

	return 0;
}

void iscsi_thread_set_free(void)
{
	kfree(iscsit_global->ts_bitmap);
}
Commit	Line	Data
e48354ce NB	1	/*******************************************************************************
	2	* This file contains the iSCSI Login Thread and Thread Queue functions.
	3	*
	4	* \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
	5	*
	6	* Licensed to the Linux Foundation under the General Public License (GPL) version 2.
	7	*
	8	* Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	******************************************************************************/
	20
	21	#include <linux/kthread.h>
	22	#include <linux/list.h>
	23	#include <linux/bitmap.h>
	24
	25	#include "iscsi_target_core.h"
	26	#include "iscsi_target_tq.h"
	27	#include "iscsi_target.h"
	28
	29	static LIST_HEAD(active_ts_list);
	30	static LIST_HEAD(inactive_ts_list);
	31	static DEFINE_SPINLOCK(active_ts_lock);
	32	static DEFINE_SPINLOCK(inactive_ts_lock);
	33	static DEFINE_SPINLOCK(ts_bitmap_lock);
	34
	35	static void iscsi_add_ts_to_active_list(struct iscsi_thread_set *ts)
	36	{
	37	spin_lock(&active_ts_lock);
	38	list_add_tail(&ts->ts_list, &active_ts_list);
	39	iscsit_global->active_ts++;
	40	spin_unlock(&active_ts_lock);
	41	}
	42
	43	extern void iscsi_add_ts_to_inactive_list(struct iscsi_thread_set *ts)
	44	{
	45	spin_lock(&inactive_ts_lock);
	46	list_add_tail(&ts->ts_list, &inactive_ts_list);
	47	iscsit_global->inactive_ts++;
	48	spin_unlock(&inactive_ts_lock);
	49	}
	50
	51	static void iscsi_del_ts_from_active_list(struct iscsi_thread_set *ts)
	52	{
	53	spin_lock(&active_ts_lock);
	54	list_del(&ts->ts_list);
	55	iscsit_global->active_ts--;
	56	spin_unlock(&active_ts_lock);
	57	}
	58
	59	static struct iscsi_thread_set *iscsi_get_ts_from_inactive_list(void)
	60	{
	61	struct iscsi_thread_set *ts;
	62
	63	spin_lock(&inactive_ts_lock);
	64	if (list_empty(&inactive_ts_list)) {
65	spin_unlock(&inactive_ts_lock);
66	return NULL;
67	}
68
69	list_for_each_entry(ts, &inactive_ts_list, ts_list)
70	break;
71
72	list_del(&ts->ts_list);
73	iscsit_global->inactive_ts--;
74	spin_unlock(&inactive_ts_lock);
75
76	return ts;
77	}
78
79	extern int iscsi_allocate_thread_sets(u32 thread_pair_count)
80	{
81	int allocated_thread_pair_count = 0, i, thread_id;
82	struct iscsi_thread_set *ts = NULL;
83
84	for (i = 0; i < thread_pair_count; i++) {
85	ts = kzalloc(sizeof(struct iscsi_thread_set), GFP_KERNEL);
86	if (!ts) {
87	pr_err("Unable to allocate memory for"
88	" thread set.\n");
89	return allocated_thread_pair_count;
90	}
91	/*
92	* Locate the next available regision in the thread_set_bitmap
93	*/
94	spin_lock(&ts_bitmap_lock);
95	thread_id = bitmap_find_free_region(iscsit_global->ts_bitmap,
96	iscsit_global->ts_bitmap_count, get_order(1));
97	spin_unlock(&ts_bitmap_lock);
98	if (thread_id < 0) {
99	pr_err("bitmap_find_free_region() failed for"
100	" thread_set_bitmap\n");
101	kfree(ts);
102	return allocated_thread_pair_count;
103	}
104
105	ts->thread_id = thread_id;
106	ts->status = ISCSI_THREAD_SET_FREE;
107	INIT_LIST_HEAD(&ts->ts_list);
108	spin_lock_init(&ts->ts_state_lock);
109	init_completion(&ts->rx_post_start_comp);
110	init_completion(&ts->tx_post_start_comp);
111	init_completion(&ts->rx_restart_comp);
112	init_completion(&ts->tx_restart_comp);
113	init_completion(&ts->rx_start_comp);
114	init_completion(&ts->tx_start_comp);
115
116	ts->create_threads = 1;
117	ts->tx_thread = kthread_run(iscsi_target_tx_thread, ts, "%s",
118	ISCSI_TX_THREAD_NAME);
119	if (IS_ERR(ts->tx_thread)) {
120	dump_stack();
121	pr_err("Unable to start iscsi_target_tx_thread\n");
122	break;
123	}
124
125	ts->rx_thread = kthread_run(iscsi_target_rx_thread, ts, "%s",
126	ISCSI_RX_THREAD_NAME);
127	if (IS_ERR(ts->rx_thread)) {
128	kthread_stop(ts->tx_thread);
129	pr_err("Unable to start iscsi_target_rx_thread\n");
130	break;
131	}
132	ts->create_threads = 0;
133
134	iscsi_add_ts_to_inactive_list(ts);
135	allocated_thread_pair_count++;
136	}
137
138	pr_debug("Spawned %d thread set(s) (%d total threads).\n",
139	allocated_thread_pair_count, allocated_thread_pair_count * 2);
140	return allocated_thread_pair_count;
141	}
142
143	extern void iscsi_deallocate_thread_sets(void)
144	{
145	u32 released_count = 0;
146	struct iscsi_thread_set *ts = NULL;
147
148	while ((ts = iscsi_get_ts_from_inactive_list())) {
149
150	spin_lock_bh(&ts->ts_state_lock);
151	ts->status = ISCSI_THREAD_SET_DIE;
152	spin_unlock_bh(&ts->ts_state_lock);
153
154	if (ts->rx_thread) {
155	send_sig(SIGINT, ts->rx_thread, 1);
156	kthread_stop(ts->rx_thread);
157	}
158	if (ts->tx_thread) {
159	send_sig(SIGINT, ts->tx_thread, 1);
160	kthread_stop(ts->tx_thread);
161	}
162	/*
163	* Release this thread_id in the thread_set_bitmap
164	*/
165	spin_lock(&ts_bitmap_lock);
166	bitmap_release_region(iscsit_global->ts_bitmap,
167	ts->thread_id, get_order(1));
168	spin_unlock(&ts_bitmap_lock);
169
170	released_count++;
171	kfree(ts);
172	}
173
174	if (released_count)
175	pr_debug("Stopped %d thread set(s) (%d total threads)."
176	"\n", released_count, released_count * 2);
177	}
178
179	static void iscsi_deallocate_extra_thread_sets(void)
180	{
181	u32 orig_count, released_count = 0;
182	struct iscsi_thread_set *ts = NULL;
183
184	orig_count = TARGET_THREAD_SET_COUNT;
185
186	while ((iscsit_global->inactive_ts + 1) > orig_count) {
187	ts = iscsi_get_ts_from_inactive_list();
188	if (!ts)
189	break;
190
191	spin_lock_bh(&ts->ts_state_lock);
192	ts->status = ISCSI_THREAD_SET_DIE;
193	spin_unlock_bh(&ts->ts_state_lock);
194
195	if (ts->rx_thread) {
196	send_sig(SIGINT, ts->rx_thread, 1);
197	kthread_stop(ts->rx_thread);
198	}
199	if (ts->tx_thread) {
200	send_sig(SIGINT, ts->tx_thread, 1);
201	kthread_stop(ts->tx_thread);
202	}
203	/*
204	* Release this thread_id in the thread_set_bitmap
205	*/
206	spin_lock(&ts_bitmap_lock);
207	bitmap_release_region(iscsit_global->ts_bitmap,
208	ts->thread_id, get_order(1));
209	spin_unlock(&ts_bitmap_lock);
210
211	released_count++;
212	kfree(ts);
213	}
214
215	if (released_count) {
216	pr_debug("Stopped %d thread set(s) (%d total threads)."
217	"\n", released_count, released_count * 2);
218	}
219	}
220
221	void iscsi_activate_thread_set(struct iscsi_conn conn, struct iscsi_thread_set ts)
222	{
223	iscsi_add_ts_to_active_list(ts);
224
225	spin_lock_bh(&ts->ts_state_lock);
226	conn->thread_set = ts;
227	ts->conn = conn;
228	spin_unlock_bh(&ts->ts_state_lock);
229	/*
230	* Start up the RX thread and wait on rx_post_start_comp. The RX
231	* Thread will then do the same for the TX Thread in
232	* iscsi_rx_thread_pre_handler().
233	*/
234	complete(&ts->rx_start_comp);
235	wait_for_completion(&ts->rx_post_start_comp);
236	}
237
238	struct iscsi_thread_set *iscsi_get_thread_set(void)
239	{
240	int allocate_ts = 0;
241	struct completion comp;
242	struct iscsi_thread_set *ts = NULL;
243	/*
244	* If no inactive thread set is available on the first call to
245	* iscsi_get_ts_from_inactive_list(), sleep for a second and
246	* try again. If still none are available after two attempts,
247	* allocate a set ourselves.
248	*/
249	get_set:
250	ts = iscsi_get_ts_from_inactive_list();
251	if (!ts) {
252	if (allocate_ts == 2)
253	iscsi_allocate_thread_sets(1);
254
255	init_completion(&comp);
256	wait_for_completion_timeout(&comp, 1 * HZ);
257
258	allocate_ts++;
259	goto get_set;
260	}
261
262	ts->delay_inactive = 1;
263	ts->signal_sent = 0;
264	ts->thread_count = 2;
265	init_completion(&ts->rx_restart_comp);
266	init_completion(&ts->tx_restart_comp);
267
268	return ts;
269	}
270
271	void iscsi_set_thread_clear(struct iscsi_conn *conn, u8 thread_clear)
272	{
273	struct iscsi_thread_set *ts = NULL;
274
275	if (!conn->thread_set) {
276	pr_err("struct iscsi_conn->thread_set is NULL\n");
277	return;
278	}
279	ts = conn->thread_set;
280
281	spin_lock_bh(&ts->ts_state_lock);
282	ts->thread_clear &= ~thread_clear;
283
284	if ((thread_clear & ISCSI_CLEAR_RX_THREAD) &&
285	(ts->blocked_threads & ISCSI_BLOCK_RX_THREAD))
286	complete(&ts->rx_restart_comp);
287	else if ((thread_clear & ISCSI_CLEAR_TX_THREAD) &&
288	(ts->blocked_threads & ISCSI_BLOCK_TX_THREAD))
289	complete(&ts->tx_restart_comp);
290	spin_unlock_bh(&ts->ts_state_lock);
291	}
292
293	void iscsi_set_thread_set_signal(struct iscsi_conn *conn, u8 signal_sent)
294	{
295	struct iscsi_thread_set *ts = NULL;
296
297	if (!conn->thread_set) {
298	pr_err("struct iscsi_conn->thread_set is NULL\n");
299	return;
300	}
301	ts = conn->thread_set;
302
303	spin_lock_bh(&ts->ts_state_lock);
304	ts->signal_sent \|= signal_sent;
305	spin_unlock_bh(&ts->ts_state_lock);
306	}
307
308	int iscsi_release_thread_set(struct iscsi_conn *conn)
309	{
310	int thread_called = 0;
311	struct iscsi_thread_set *ts = NULL;
312
313	if (!conn \|\| !conn->thread_set) {
314	pr_err("connection or thread set pointer is NULL\n");
315	BUG();
316	}
317	ts = conn->thread_set;
318
319	spin_lock_bh(&ts->ts_state_lock);
320	ts->status = ISCSI_THREAD_SET_RESET;
321
322	if (!strncmp(current->comm, ISCSI_RX_THREAD_NAME,
323	strlen(ISCSI_RX_THREAD_NAME)))
324	thread_called = ISCSI_RX_THREAD;
325	else if (!strncmp(current->comm, ISCSI_TX_THREAD_NAME,
326	strlen(ISCSI_TX_THREAD_NAME)))
327	thread_called = ISCSI_TX_THREAD;
328
329	if (ts->rx_thread && (thread_called == ISCSI_TX_THREAD) &&
330	(ts->thread_clear & ISCSI_CLEAR_RX_THREAD)) {
331
332	if (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD)) {
333	send_sig(SIGINT, ts->rx_thread, 1);
334	ts->signal_sent \|= ISCSI_SIGNAL_RX_THREAD;
335	}
336	ts->blocked_threads \|= ISCSI_BLOCK_RX_THREAD;
337	spin_unlock_bh(&ts->ts_state_lock);
338	wait_for_completion(&ts->rx_restart_comp);
339	spin_lock_bh(&ts->ts_state_lock);
340	ts->blocked_threads &= ~ISCSI_BLOCK_RX_THREAD;
341	}
342	if (ts->tx_thread && (thread_called == ISCSI_RX_THREAD) &&
343	(ts->thread_clear & ISCSI_CLEAR_TX_THREAD)) {
344
345	if (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD)) {
346	send_sig(SIGINT, ts->tx_thread, 1);
347	ts->signal_sent \|= ISCSI_SIGNAL_TX_THREAD;
348	}
349	ts->blocked_threads \|= ISCSI_BLOCK_TX_THREAD;
350	spin_unlock_bh(&ts->ts_state_lock);
351	wait_for_completion(&ts->tx_restart_comp);
352	spin_lock_bh(&ts->ts_state_lock);
353	ts->blocked_threads &= ~ISCSI_BLOCK_TX_THREAD;
354	}
355
356	ts->conn = NULL;
357	ts->status = ISCSI_THREAD_SET_FREE;
358	spin_unlock_bh(&ts->ts_state_lock);
359
360	return 0;
361	}
362
363	int iscsi_thread_set_force_reinstatement(struct iscsi_conn *conn)
364	{
365	struct iscsi_thread_set *ts;
366
367	if (!conn->thread_set)
368	return -1;
369	ts = conn->thread_set;
370
371	spin_lock_bh(&ts->ts_state_lock);
372	if (ts->status != ISCSI_THREAD_SET_ACTIVE) {
373	spin_unlock_bh(&ts->ts_state_lock);
374	return -1;
375	}
376
377	if (ts->tx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD))) {
378	send_sig(SIGINT, ts->tx_thread, 1);
379	ts->signal_sent \|= ISCSI_SIGNAL_TX_THREAD;
380	}
381	if (ts->rx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD))) {
382	send_sig(SIGINT, ts->rx_thread, 1);
383	ts->signal_sent \|= ISCSI_SIGNAL_RX_THREAD;
384	}
385	spin_unlock_bh(&ts->ts_state_lock);
386
387	return 0;
388	}
389
390	static void iscsi_check_to_add_additional_sets(void)
391	{
392	int thread_sets_add;
393
394	spin_lock(&inactive_ts_lock);
395	thread_sets_add = iscsit_global->inactive_ts;
396	spin_unlock(&inactive_ts_lock);
397	if (thread_sets_add == 1)
398	iscsi_allocate_thread_sets(1);
399	}
400
401	static int iscsi_signal_thread_pre_handler(struct iscsi_thread_set *ts)
402	{
403	spin_lock_bh(&ts->ts_state_lock);
404	if ((ts->status == ISCSI_THREAD_SET_DIE) \|\| signal_pending(current)) {
405	spin_unlock_bh(&ts->ts_state_lock);
406	return -1;
407	}
408	spin_unlock_bh(&ts->ts_state_lock);
409
410	return 0;
411	}
412
413	struct iscsi_conn iscsi_rx_thread_pre_handler(struct iscsi_thread_set ts)
414	{
415	int ret;
416
417	spin_lock_bh(&ts->ts_state_lock);
418	if (ts->create_threads) {
419	spin_unlock_bh(&ts->ts_state_lock);
420	goto sleep;
421	}
422
423	flush_signals(current);
424
425	if (ts->delay_inactive && (--ts->thread_count == 0)) {
426	spin_unlock_bh(&ts->ts_state_lock);
427	iscsi_del_ts_from_active_list(ts);
428
429	if (!iscsit_global->in_shutdown)
430	iscsi_deallocate_extra_thread_sets();
431
432	iscsi_add_ts_to_inactive_list(ts);
433	spin_lock_bh(&ts->ts_state_lock);
434	}
435
436	if ((ts->status == ISCSI_THREAD_SET_RESET) &&
437	(ts->thread_clear & ISCSI_CLEAR_RX_THREAD))
438	complete(&ts->rx_restart_comp);
439
440	ts->thread_clear &= ~ISCSI_CLEAR_RX_THREAD;
441	spin_unlock_bh(&ts->ts_state_lock);
442	sleep:
443	ret = wait_for_completion_interruptible(&ts->rx_start_comp);
444	if (ret != 0)
445	return NULL;
446
447	if (iscsi_signal_thread_pre_handler(ts) < 0)
448	return NULL;
449
450	if (!ts->conn) {
451	pr_err("struct iscsi_thread_set->conn is NULL for"
452	" thread_id: %d, going back to sleep\n", ts->thread_id);
453	goto sleep;
454	}
455	iscsi_check_to_add_additional_sets();
456	/*
457	* The RX Thread starts up the TX Thread and sleeps.
458	*/
459	ts->thread_clear \|= ISCSI_CLEAR_RX_THREAD;
460	complete(&ts->tx_start_comp);
461	wait_for_completion(&ts->tx_post_start_comp);
462
463	return ts->conn;
464	}
465
466	struct iscsi_conn iscsi_tx_thread_pre_handler(struct iscsi_thread_set ts)
467	{
468	int ret;
469
470	spin_lock_bh(&ts->ts_state_lock);
471	if (ts->create_threads) {
472	spin_unlock_bh(&ts->ts_state_lock);
473	goto sleep;
474	}
475
476	flush_signals(current);
477
478	if (ts->delay_inactive && (--ts->thread_count == 0)) {
479	spin_unlock_bh(&ts->ts_state_lock);
480	iscsi_del_ts_from_active_list(ts);
481
482	if (!iscsit_global->in_shutdown)
483	iscsi_deallocate_extra_thread_sets();
484
485	iscsi_add_ts_to_inactive_list(ts);
486	spin_lock_bh(&ts->ts_state_lock);
487	}
488	if ((ts->status == ISCSI_THREAD_SET_RESET) &&
489	(ts->thread_clear & ISCSI_CLEAR_TX_THREAD))
490	complete(&ts->tx_restart_comp);
491
492	ts->thread_clear &= ~ISCSI_CLEAR_TX_THREAD;
493	spin_unlock_bh(&ts->ts_state_lock);
494	sleep:
495	ret = wait_for_completion_interruptible(&ts->tx_start_comp);
496	if (ret != 0)
497	return NULL;
498
499	if (iscsi_signal_thread_pre_handler(ts) < 0)
500	return NULL;
501
502	if (!ts->conn) {
503	pr_err("struct iscsi_thread_set->conn is NULL for "
504	" thread_id: %d, going back to sleep\n",
505	ts->thread_id);
506	goto sleep;
507	}
508
509	iscsi_check_to_add_additional_sets();
510	/*
511	* From the TX thread, up the tx_post_start_comp that the RX Thread is
512	* sleeping on in iscsi_rx_thread_pre_handler(), then up the
513	* rx_post_start_comp that iscsi_activate_thread_set() is sleeping on.
514	*/
515	ts->thread_clear \|= ISCSI_CLEAR_TX_THREAD;
516	complete(&ts->tx_post_start_comp);
517	complete(&ts->rx_post_start_comp);
518
519	spin_lock_bh(&ts->ts_state_lock);
520	ts->status = ISCSI_THREAD_SET_ACTIVE;
521	spin_unlock_bh(&ts->ts_state_lock);
522
523	return ts->conn;
524	}
525
526	int iscsi_thread_set_init(void)
527	{
528	int size;
529
530	iscsit_global->ts_bitmap_count = ISCSI_TS_BITMAP_BITS;
531
532	size = BITS_TO_LONGS(iscsit_global->ts_bitmap_count) * sizeof(long);
533	iscsit_global->ts_bitmap = kzalloc(size, GFP_KERNEL);
534	if (!iscsit_global->ts_bitmap) {
535	pr_err("Unable to allocate iscsit_global->ts_bitmap\n");
536	return -ENOMEM;
537	}
538
e48354ce NB	539	return 0;
	540	}
	541
	542	void iscsi_thread_set_free(void)
	543	{
	544	kfree(iscsit_global->ts_bitmap);
	545	}