?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 3.11-rc3
[cris-mirror.git] / drivers / target / iscsi / iscsi_target_tq.c
blob81289520f96b3915bf1e4e8cfaf330ac27625566
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 static 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 ts = list_first_entry(&inactive_ts_list, struct iscsi_thread_set, ts_list);
70
71 list_del(&ts->ts_list);
72 iscsit_global->inactive_ts--;
73 spin_unlock(&inactive_ts_lock);
74
75 return ts;
76 }
77
78 int iscsi_allocate_thread_sets(u32 thread_pair_count)
79 {
80 int allocated_thread_pair_count = 0, i, thread_id;
81 struct iscsi_thread_set *ts = NULL;
82
83 for (i = 0; i < thread_pair_count; i++) {
84 ts = kzalloc(sizeof(struct iscsi_thread_set), GFP_KERNEL);
85 if (!ts) {
86 pr_err("Unable to allocate memory for"
87 " thread set.\n");
88 return allocated_thread_pair_count;
89 }
90 /*
91 * Locate the next available regision in the thread_set_bitmap
92 */
93 spin_lock(&ts_bitmap_lock);
94 thread_id = bitmap_find_free_region(iscsit_global->ts_bitmap,
95 iscsit_global->ts_bitmap_count, get_order(1));
96 spin_unlock(&ts_bitmap_lock);
97 if (thread_id < 0) {
98 pr_err("bitmap_find_free_region() failed for"
99 " thread_set_bitmap\n");
100 kfree(ts);
101 return allocated_thread_pair_count;
102 }
103
104 ts->thread_id = thread_id;
105 ts->status = ISCSI_THREAD_SET_FREE;
106 INIT_LIST_HEAD(&ts->ts_list);
107 spin_lock_init(&ts->ts_state_lock);
108 init_completion(&ts->rx_post_start_comp);
109 init_completion(&ts->tx_post_start_comp);
110 init_completion(&ts->rx_restart_comp);
111 init_completion(&ts->tx_restart_comp);
112 init_completion(&ts->rx_start_comp);
113 init_completion(&ts->tx_start_comp);
114
115 ts->create_threads = 1;
116 ts->tx_thread = kthread_run(iscsi_target_tx_thread, ts, "%s",
117 ISCSI_TX_THREAD_NAME);
118 if (IS_ERR(ts->tx_thread)) {
119 dump_stack();
120 pr_err("Unable to start iscsi_target_tx_thread\n");
121 break;
122 }
123
124 ts->rx_thread = kthread_run(iscsi_target_rx_thread, ts, "%s",
125 ISCSI_RX_THREAD_NAME);
126 if (IS_ERR(ts->rx_thread)) {
127 kthread_stop(ts->tx_thread);
128 pr_err("Unable to start iscsi_target_rx_thread\n");
129 break;
130 }
131 ts->create_threads = 0;
132
133 iscsi_add_ts_to_inactive_list(ts);
134 allocated_thread_pair_count++;
135 }
136
137 pr_debug("Spawned %d thread set(s) (%d total threads).\n",
138 allocated_thread_pair_count, allocated_thread_pair_count * 2);
139 return allocated_thread_pair_count;
140 }
141
142 void iscsi_deallocate_thread_sets(void)
143 {
144 u32 released_count = 0;
145 struct iscsi_thread_set *ts = NULL;
146
147 while ((ts = iscsi_get_ts_from_inactive_list())) {
148
149 spin_lock_bh(&ts->ts_state_lock);
150 ts->status = ISCSI_THREAD_SET_DIE;
151 spin_unlock_bh(&ts->ts_state_lock);
152
153 if (ts->rx_thread) {
154 send_sig(SIGINT, ts->rx_thread, 1);
155 kthread_stop(ts->rx_thread);
156 }
157 if (ts->tx_thread) {
158 send_sig(SIGINT, ts->tx_thread, 1);
159 kthread_stop(ts->tx_thread);
160 }
161 /*
162 * Release this thread_id in the thread_set_bitmap
163 */
164 spin_lock(&ts_bitmap_lock);
165 bitmap_release_region(iscsit_global->ts_bitmap,
166 ts->thread_id, get_order(1));
167 spin_unlock(&ts_bitmap_lock);
168
169 released_count++;
170 kfree(ts);
171 }
172
173 if (released_count)
174 pr_debug("Stopped %d thread set(s) (%d total threads)."
175 "\n", released_count, released_count * 2);
176 }
177
178 static void iscsi_deallocate_extra_thread_sets(void)
179 {
180 u32 orig_count, released_count = 0;
181 struct iscsi_thread_set *ts = NULL;
182
183 orig_count = TARGET_THREAD_SET_COUNT;
184
185 while ((iscsit_global->inactive_ts + 1) > orig_count) {
186 ts = iscsi_get_ts_from_inactive_list();
187 if (!ts)
188 break;
189
190 spin_lock_bh(&ts->ts_state_lock);
191 ts->status = ISCSI_THREAD_SET_DIE;
192 spin_unlock_bh(&ts->ts_state_lock);
193
194 if (ts->rx_thread) {
195 send_sig(SIGINT, ts->rx_thread, 1);
196 kthread_stop(ts->rx_thread);
197 }
198 if (ts->tx_thread) {
199 send_sig(SIGINT, ts->tx_thread, 1);
200 kthread_stop(ts->tx_thread);
201 }
202 /*
203 * Release this thread_id in the thread_set_bitmap
204 */
205 spin_lock(&ts_bitmap_lock);
206 bitmap_release_region(iscsit_global->ts_bitmap,
207 ts->thread_id, get_order(1));
208 spin_unlock(&ts_bitmap_lock);
209
210 released_count++;
211 kfree(ts);
212 }
213
214 if (released_count) {
215 pr_debug("Stopped %d thread set(s) (%d total threads)."
216 "\n", released_count, released_count * 2);
217 }
218 }
219
220 void iscsi_activate_thread_set(struct iscsi_conn *conn, struct iscsi_thread_set *ts)
221 {
222 iscsi_add_ts_to_active_list(ts);
223
224 spin_lock_bh(&ts->ts_state_lock);
225 conn->thread_set = ts;
226 ts->conn = conn;
227 spin_unlock_bh(&ts->ts_state_lock);
228 /*
229 * Start up the RX thread and wait on rx_post_start_comp. The RX
230 * Thread will then do the same for the TX Thread in
231 * iscsi_rx_thread_pre_handler().
232 */
233 complete(&ts->rx_start_comp);
234 wait_for_completion(&ts->rx_post_start_comp);
235 }
236
237 struct iscsi_thread_set *iscsi_get_thread_set(void)
238 {
239 int allocate_ts = 0;
240 struct completion comp;
241 struct iscsi_thread_set *ts = NULL;
242 /*
243 * If no inactive thread set is available on the first call to
244 * iscsi_get_ts_from_inactive_list(), sleep for a second and
245 * try again. If still none are available after two attempts,
246 * allocate a set ourselves.
247 */
248 get_set:
249 ts = iscsi_get_ts_from_inactive_list();
250 if (!ts) {
251 if (allocate_ts == 2)
252 iscsi_allocate_thread_sets(1);
253
254 init_completion(&comp);
255 wait_for_completion_timeout(&comp, 1 * HZ);
256
257 allocate_ts++;
258 goto get_set;
259 }
260
261 ts->delay_inactive = 1;
262 ts->signal_sent = 0;
263 ts->thread_count = 2;
264 init_completion(&ts->rx_restart_comp);
265 init_completion(&ts->tx_restart_comp);
266
267 return ts;
268 }
269
270 void iscsi_set_thread_clear(struct iscsi_conn *conn, u8 thread_clear)
271 {
272 struct iscsi_thread_set *ts = NULL;
273
274 if (!conn->thread_set) {
275 pr_err("struct iscsi_conn->thread_set is NULL\n");
276 return;
277 }
278 ts = conn->thread_set;
279
280 spin_lock_bh(&ts->ts_state_lock);
281 ts->thread_clear &= ~thread_clear;
282
283 if ((thread_clear & ISCSI_CLEAR_RX_THREAD) &&
284 (ts->blocked_threads & ISCSI_BLOCK_RX_THREAD))
285 complete(&ts->rx_restart_comp);
286 else if ((thread_clear & ISCSI_CLEAR_TX_THREAD) &&
287 (ts->blocked_threads & ISCSI_BLOCK_TX_THREAD))
288 complete(&ts->tx_restart_comp);
289 spin_unlock_bh(&ts->ts_state_lock);
290 }
291
292 void iscsi_set_thread_set_signal(struct iscsi_conn *conn, u8 signal_sent)
293 {
294 struct iscsi_thread_set *ts = NULL;
295
296 if (!conn->thread_set) {
297 pr_err("struct iscsi_conn->thread_set is NULL\n");
298 return;
299 }
300 ts = conn->thread_set;
301
302 spin_lock_bh(&ts->ts_state_lock);
303 ts->signal_sent |= signal_sent;
304 spin_unlock_bh(&ts->ts_state_lock);
305 }
306
307 int iscsi_release_thread_set(struct iscsi_conn *conn)
308 {
309 int thread_called = 0;
310 struct iscsi_thread_set *ts = NULL;
311
312 if (!conn || !conn->thread_set) {
313 pr_err("connection or thread set pointer is NULL\n");
314 BUG();
315 }
316 ts = conn->thread_set;
317
318 spin_lock_bh(&ts->ts_state_lock);
319 ts->status = ISCSI_THREAD_SET_RESET;
320
321 if (!strncmp(current->comm, ISCSI_RX_THREAD_NAME,
322 strlen(ISCSI_RX_THREAD_NAME)))
323 thread_called = ISCSI_RX_THREAD;
324 else if (!strncmp(current->comm, ISCSI_TX_THREAD_NAME,
325 strlen(ISCSI_TX_THREAD_NAME)))
326 thread_called = ISCSI_TX_THREAD;
327
328 if (ts->rx_thread && (thread_called == ISCSI_TX_THREAD) &&
329 (ts->thread_clear & ISCSI_CLEAR_RX_THREAD)) {
330
331 if (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD)) {
332 send_sig(SIGINT, ts->rx_thread, 1);
333 ts->signal_sent |= ISCSI_SIGNAL_RX_THREAD;
334 }
335 ts->blocked_threads |= ISCSI_BLOCK_RX_THREAD;
336 spin_unlock_bh(&ts->ts_state_lock);
337 wait_for_completion(&ts->rx_restart_comp);
338 spin_lock_bh(&ts->ts_state_lock);
339 ts->blocked_threads &= ~ISCSI_BLOCK_RX_THREAD;
340 }
341 if (ts->tx_thread && (thread_called == ISCSI_RX_THREAD) &&
342 (ts->thread_clear & ISCSI_CLEAR_TX_THREAD)) {
343
344 if (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD)) {
345 send_sig(SIGINT, ts->tx_thread, 1);
346 ts->signal_sent |= ISCSI_SIGNAL_TX_THREAD;
347 }
348 ts->blocked_threads |= ISCSI_BLOCK_TX_THREAD;
349 spin_unlock_bh(&ts->ts_state_lock);
350 wait_for_completion(&ts->tx_restart_comp);
351 spin_lock_bh(&ts->ts_state_lock);
352 ts->blocked_threads &= ~ISCSI_BLOCK_TX_THREAD;
353 }
354
355 ts->conn = NULL;
356 ts->status = ISCSI_THREAD_SET_FREE;
357 spin_unlock_bh(&ts->ts_state_lock);
358
359 return 0;
360 }
361
362 int iscsi_thread_set_force_reinstatement(struct iscsi_conn *conn)
363 {
364 struct iscsi_thread_set *ts;
365
366 if (!conn->thread_set)
367 return -1;
368 ts = conn->thread_set;
369
370 spin_lock_bh(&ts->ts_state_lock);
371 if (ts->status != ISCSI_THREAD_SET_ACTIVE) {
372 spin_unlock_bh(&ts->ts_state_lock);
373 return -1;
374 }
375
376 if (ts->tx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_TX_THREAD))) {
377 send_sig(SIGINT, ts->tx_thread, 1);
378 ts->signal_sent |= ISCSI_SIGNAL_TX_THREAD;
379 }
380 if (ts->rx_thread && (!(ts->signal_sent & ISCSI_SIGNAL_RX_THREAD))) {
381 send_sig(SIGINT, ts->rx_thread, 1);
382 ts->signal_sent |= ISCSI_SIGNAL_RX_THREAD;
383 }
384 spin_unlock_bh(&ts->ts_state_lock);
385
386 return 0;
387 }
388
389 static void iscsi_check_to_add_additional_sets(void)
390 {
391 int thread_sets_add;
392
393 spin_lock(&inactive_ts_lock);
394 thread_sets_add = iscsit_global->inactive_ts;
395 spin_unlock(&inactive_ts_lock);
396 if (thread_sets_add == 1)
397 iscsi_allocate_thread_sets(1);
398 }
399
400 static int iscsi_signal_thread_pre_handler(struct iscsi_thread_set *ts)
401 {
402 spin_lock_bh(&ts->ts_state_lock);
403 if ((ts->status == ISCSI_THREAD_SET_DIE) || signal_pending(current)) {
404 spin_unlock_bh(&ts->ts_state_lock);
405 return -1;
406 }
407 spin_unlock_bh(&ts->ts_state_lock);
408
409 return 0;
410 }
411
412 struct iscsi_conn *iscsi_rx_thread_pre_handler(struct iscsi_thread_set *ts)
413 {
414 int ret;
415
416 spin_lock_bh(&ts->ts_state_lock);
417 if (ts->create_threads) {
418 spin_unlock_bh(&ts->ts_state_lock);
419 goto sleep;
420 }
421
422 flush_signals(current);
423
424 if (ts->delay_inactive && (--ts->thread_count == 0)) {
425 spin_unlock_bh(&ts->ts_state_lock);
426 iscsi_del_ts_from_active_list(ts);
427
428 if (!iscsit_global->in_shutdown)
429 iscsi_deallocate_extra_thread_sets();
430
431 iscsi_add_ts_to_inactive_list(ts);
432 spin_lock_bh(&ts->ts_state_lock);
433 }
434
435 if ((ts->status == ISCSI_THREAD_SET_RESET) &&
436 (ts->thread_clear & ISCSI_CLEAR_RX_THREAD))
437 complete(&ts->rx_restart_comp);
438
439 ts->thread_clear &= ~ISCSI_CLEAR_RX_THREAD;
440 spin_unlock_bh(&ts->ts_state_lock);
441 sleep:
442 ret = wait_for_completion_interruptible(&ts->rx_start_comp);
443 if (ret != 0)
444 return NULL;
445
446 if (iscsi_signal_thread_pre_handler(ts) < 0)
447 return NULL;
448
449 if (!ts->conn) {
450 pr_err("struct iscsi_thread_set->conn is NULL for"
451 " thread_id: %d, going back to sleep\n", ts->thread_id);
452 goto sleep;
453 }
454 iscsi_check_to_add_additional_sets();
455 /*
456 * The RX Thread starts up the TX Thread and sleeps.
457 */
458 ts->thread_clear |= ISCSI_CLEAR_RX_THREAD;
459 complete(&ts->tx_start_comp);
460 wait_for_completion(&ts->tx_post_start_comp);
461
462 return ts->conn;
463 }
464
465 struct iscsi_conn *iscsi_tx_thread_pre_handler(struct iscsi_thread_set *ts)
466 {
467 int ret;
468
469 spin_lock_bh(&ts->ts_state_lock);
470 if (ts->create_threads) {
471 spin_unlock_bh(&ts->ts_state_lock);
472 goto sleep;
473 }
474
475 flush_signals(current);
476
477 if (ts->delay_inactive && (--ts->thread_count == 0)) {
478 spin_unlock_bh(&ts->ts_state_lock);
479 iscsi_del_ts_from_active_list(ts);
480
481 if (!iscsit_global->in_shutdown)
482 iscsi_deallocate_extra_thread_sets();
483
484 iscsi_add_ts_to_inactive_list(ts);
485 spin_lock_bh(&ts->ts_state_lock);
486 }
487 if ((ts->status == ISCSI_THREAD_SET_RESET) &&
488 (ts->thread_clear & ISCSI_CLEAR_TX_THREAD))
489 complete(&ts->tx_restart_comp);
490
491 ts->thread_clear &= ~ISCSI_CLEAR_TX_THREAD;
492 spin_unlock_bh(&ts->ts_state_lock);
493 sleep:
494 ret = wait_for_completion_interruptible(&ts->tx_start_comp);
495 if (ret != 0)
496 return NULL;
497
498 if (iscsi_signal_thread_pre_handler(ts) < 0)
499 return NULL;
500
501 if (!ts->conn) {
502 pr_err("struct iscsi_thread_set->conn is NULL for "
503 " thread_id: %d, going back to sleep\n",
504 ts->thread_id);
505 goto sleep;
506 }
507
508 iscsi_check_to_add_additional_sets();
509 /*
510 * From the TX thread, up the tx_post_start_comp that the RX Thread is
511 * sleeping on in iscsi_rx_thread_pre_handler(), then up the
512 * rx_post_start_comp that iscsi_activate_thread_set() is sleeping on.
513 */
514 ts->thread_clear |= ISCSI_CLEAR_TX_THREAD;
515 complete(&ts->tx_post_start_comp);
516 complete(&ts->rx_post_start_comp);
517
518 spin_lock_bh(&ts->ts_state_lock);
519 ts->status = ISCSI_THREAD_SET_ACTIVE;
520 spin_unlock_bh(&ts->ts_state_lock);
521
522 return ts->conn;
523 }
524
525 int iscsi_thread_set_init(void)
526 {
527 int size;
528
529 iscsit_global->ts_bitmap_count = ISCSI_TS_BITMAP_BITS;
530
531 size = BITS_TO_LONGS(iscsit_global->ts_bitmap_count) * sizeof(long);
532 iscsit_global->ts_bitmap = kzalloc(size, GFP_KERNEL);
533 if (!iscsit_global->ts_bitmap) {
534 pr_err("Unable to allocate iscsit_global->ts_bitmap\n");
535 return -ENOMEM;
536 }
537
538 return 0;
539 }
540
541 void iscsi_thread_set_free(void)
542 {
543 kfree(iscsit_global->ts_bitmap);
544 }
CRIS linux kernel tree