drivers/target/iscsi/iscsi_target_tq.c

   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
 539         spin_lock_init(&active_ts_lock);
 540         spin_lock_init(&inactive_ts_lock);
 541         spin_lock_init(&ts_bitmap_lock);
 542         INIT_LIST_HEAD(&active_ts_list);
 543         INIT_LIST_HEAD(&inactive_ts_list);
 544
 545         return 0;
 546 }
 547
 548 void iscsi_thread_set_free(void)
 549 {
 550         kfree(iscsit_global->ts_bitmap);
 551 }