f9539af28f028cc68996265aedf051dc0eafe84e
[linux-2.6.git] / drivers / scsi / libiscsi.c
1 /*
2  * iSCSI lib functions
3  *
4  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
5  * Copyright (C) 2004 - 2006 Mike Christie
6  * Copyright (C) 2004 - 2005 Dmitry Yusupov
7  * Copyright (C) 2004 - 2005 Alex Aizman
8  * maintained by open-iscsi@googlegroups.com
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  * You should have received a copy of the GNU General Public License
21  * along with this program; if not, write to the Free Software
22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23  */
24 #include <linux/types.h>
25 #include <linux/kfifo.h>
26 #include <linux/delay.h>
27 #include <linux/log2.h>
28 #include <asm/unaligned.h>
29 #include <net/tcp.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <scsi/scsi_device.h>
32 #include <scsi/scsi_eh.h>
33 #include <scsi/scsi_tcq.h>
34 #include <scsi/scsi_host.h>
35 #include <scsi/scsi.h>
36 #include <scsi/iscsi_proto.h>
37 #include <scsi/scsi_transport.h>
38 #include <scsi/scsi_transport_iscsi.h>
39 #include <scsi/libiscsi.h>
40
41 /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
42 #define SNA32_CHECK 2147483648UL
43
44 static int iscsi_sna_lt(u32 n1, u32 n2)
45 {
46         return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) ||
47                             (n1 > n2 && (n2 - n1 < SNA32_CHECK)));
48 }
49
50 /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
51 static int iscsi_sna_lte(u32 n1, u32 n2)
52 {
53         return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) ||
54                             (n1 > n2 && (n2 - n1 < SNA32_CHECK)));
55 }
56
57 void
58 iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr)
59 {
60         uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn);
61         uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn);
62
63         /*
64          * standard specifies this check for when to update expected and
65          * max sequence numbers
66          */
67         if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1))
68                 return;
69
70         if (exp_cmdsn != session->exp_cmdsn &&
71             !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn))
72                 session->exp_cmdsn = exp_cmdsn;
73
74         if (max_cmdsn != session->max_cmdsn &&
75             !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) {
76                 session->max_cmdsn = max_cmdsn;
77                 /*
78                  * if the window closed with IO queued, then kick the
79                  * xmit thread
80                  */
81                 if (!list_empty(&session->leadconn->xmitqueue) ||
82                     !list_empty(&session->leadconn->mgmtqueue)) {
83                         if (!(session->tt->caps & CAP_DATA_PATH_OFFLOAD))
84                                 scsi_queue_work(session->host,
85                                                 &session->leadconn->xmitwork);
86                 }
87         }
88 }
89 EXPORT_SYMBOL_GPL(iscsi_update_cmdsn);
90
91 void iscsi_prep_unsolicit_data_pdu(struct iscsi_task *task,
92                                    struct iscsi_data *hdr)
93 {
94         struct iscsi_conn *conn = task->conn;
95
96         memset(hdr, 0, sizeof(struct iscsi_data));
97         hdr->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
98         hdr->datasn = cpu_to_be32(task->unsol_datasn);
99         task->unsol_datasn++;
100         hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
101         memcpy(hdr->lun, task->hdr->lun, sizeof(hdr->lun));
102
103         hdr->itt = task->hdr->itt;
104         hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
105         hdr->offset = cpu_to_be32(task->unsol_offset);
106
107         if (task->unsol_count > conn->max_xmit_dlength) {
108                 hton24(hdr->dlength, conn->max_xmit_dlength);
109                 task->data_count = conn->max_xmit_dlength;
110                 task->unsol_offset += task->data_count;
111                 hdr->flags = 0;
112         } else {
113                 hton24(hdr->dlength, task->unsol_count);
114                 task->data_count = task->unsol_count;
115                 hdr->flags = ISCSI_FLAG_CMD_FINAL;
116         }
117 }
118 EXPORT_SYMBOL_GPL(iscsi_prep_unsolicit_data_pdu);
119
120 static int iscsi_add_hdr(struct iscsi_task *task, unsigned len)
121 {
122         unsigned exp_len = task->hdr_len + len;
123
124         if (exp_len > task->hdr_max) {
125                 WARN_ON(1);
126                 return -EINVAL;
127         }
128
129         WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */
130         task->hdr_len = exp_len;
131         return 0;
132 }
133
134 /*
135  * make an extended cdb AHS
136  */
137 static int iscsi_prep_ecdb_ahs(struct iscsi_task *task)
138 {
139         struct scsi_cmnd *cmd = task->sc;
140         unsigned rlen, pad_len;
141         unsigned short ahslength;
142         struct iscsi_ecdb_ahdr *ecdb_ahdr;
143         int rc;
144
145         ecdb_ahdr = iscsi_next_hdr(task);
146         rlen = cmd->cmd_len - ISCSI_CDB_SIZE;
147
148         BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb));
149         ahslength = rlen + sizeof(ecdb_ahdr->reserved);
150
151         pad_len = iscsi_padding(rlen);
152
153         rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) +
154                            sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len);
155         if (rc)
156                 return rc;
157
158         if (pad_len)
159                 memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len);
160
161         ecdb_ahdr->ahslength = cpu_to_be16(ahslength);
162         ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB;
163         ecdb_ahdr->reserved = 0;
164         memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen);
165
166         debug_scsi("iscsi_prep_ecdb_ahs: varlen_cdb_len %d "
167                    "rlen %d pad_len %d ahs_length %d iscsi_headers_size %u\n",
168                    cmd->cmd_len, rlen, pad_len, ahslength, task->hdr_len);
169
170         return 0;
171 }
172
173 static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
174 {
175         struct scsi_cmnd *sc = task->sc;
176         struct iscsi_rlength_ahdr *rlen_ahdr;
177         int rc;
178
179         rlen_ahdr = iscsi_next_hdr(task);
180         rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr));
181         if (rc)
182                 return rc;
183
184         rlen_ahdr->ahslength =
185                 cpu_to_be16(sizeof(rlen_ahdr->read_length) +
186                                                   sizeof(rlen_ahdr->reserved));
187         rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH;
188         rlen_ahdr->reserved = 0;
189         rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length);
190
191         debug_scsi("bidi-in rlen_ahdr->read_length(%d) "
192                    "rlen_ahdr->ahslength(%d)\n",
193                    be32_to_cpu(rlen_ahdr->read_length),
194                    be16_to_cpu(rlen_ahdr->ahslength));
195         return 0;
196 }
197
198 /**
199  * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
200  * @task: iscsi task
201  *
202  * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set
203  * fields like dlength or final based on how much data it sends
204  */
205 static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
206 {
207         struct iscsi_conn *conn = task->conn;
208         struct iscsi_session *session = conn->session;
209         struct iscsi_cmd *hdr = task->hdr;
210         struct scsi_cmnd *sc = task->sc;
211         unsigned hdrlength, cmd_len;
212         int rc;
213
214         task->hdr_len = 0;
215         rc = iscsi_add_hdr(task, sizeof(*hdr));
216         if (rc)
217                 return rc;
218         hdr->opcode = ISCSI_OP_SCSI_CMD;
219         hdr->flags = ISCSI_ATTR_SIMPLE;
220         int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
221         hdr->itt = build_itt(task->itt, session->age);
222         hdr->cmdsn = cpu_to_be32(session->cmdsn);
223         session->cmdsn++;
224         hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
225         cmd_len = sc->cmd_len;
226         if (cmd_len < ISCSI_CDB_SIZE)
227                 memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len);
228         else if (cmd_len > ISCSI_CDB_SIZE) {
229                 rc = iscsi_prep_ecdb_ahs(task);
230                 if (rc)
231                         return rc;
232                 cmd_len = ISCSI_CDB_SIZE;
233         }
234         memcpy(hdr->cdb, sc->cmnd, cmd_len);
235
236         task->imm_count = 0;
237         if (scsi_bidi_cmnd(sc)) {
238                 hdr->flags |= ISCSI_FLAG_CMD_READ;
239                 rc = iscsi_prep_bidi_ahs(task);
240                 if (rc)
241                         return rc;
242         }
243         if (sc->sc_data_direction == DMA_TO_DEVICE) {
244                 unsigned out_len = scsi_out(sc)->length;
245                 hdr->data_length = cpu_to_be32(out_len);
246                 hdr->flags |= ISCSI_FLAG_CMD_WRITE;
247                 /*
248                  * Write counters:
249                  *
250                  *      imm_count       bytes to be sent right after
251                  *                      SCSI PDU Header
252                  *
253                  *      unsol_count     bytes(as Data-Out) to be sent
254                  *                      without R2T ack right after
255                  *                      immediate data
256                  *
257                  *      r2t_data_count  bytes to be sent via R2T ack's
258                  *
259                  *      pad_count       bytes to be sent as zero-padding
260                  */
261                 task->unsol_count = 0;
262                 task->unsol_offset = 0;
263                 task->unsol_datasn = 0;
264
265                 if (session->imm_data_en) {
266                         if (out_len >= session->first_burst)
267                                 task->imm_count = min(session->first_burst,
268                                                         conn->max_xmit_dlength);
269                         else
270                                 task->imm_count = min(out_len,
271                                                         conn->max_xmit_dlength);
272                         hton24(hdr->dlength, task->imm_count);
273                 } else
274                         zero_data(hdr->dlength);
275
276                 if (!session->initial_r2t_en) {
277                         task->unsol_count = min(session->first_burst, out_len)
278                                                              - task->imm_count;
279                         task->unsol_offset = task->imm_count;
280                 }
281
282                 if (!task->unsol_count)
283                         /* No unsolicit Data-Out's */
284                         hdr->flags |= ISCSI_FLAG_CMD_FINAL;
285         } else {
286                 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
287                 zero_data(hdr->dlength);
288                 hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
289
290                 if (sc->sc_data_direction == DMA_FROM_DEVICE)
291                         hdr->flags |= ISCSI_FLAG_CMD_READ;
292         }
293
294         /* calculate size of additional header segments (AHSs) */
295         hdrlength = task->hdr_len - sizeof(*hdr);
296
297         WARN_ON(hdrlength & (ISCSI_PAD_LEN-1));
298         hdrlength /= ISCSI_PAD_LEN;
299
300         WARN_ON(hdrlength >= 256);
301         hdr->hlength = hdrlength & 0xFF;
302
303         if (conn->session->tt->init_task &&
304             conn->session->tt->init_task(task))
305                 return -EIO;
306
307         task->state = ISCSI_TASK_RUNNING;
308         list_move_tail(&task->running, &conn->run_list);
309
310         conn->scsicmd_pdus_cnt++;
311         debug_scsi("iscsi prep [%s cid %d sc %p cdb 0x%x itt 0x%x len %d "
312                    "bidi_len %d cmdsn %d win %d]\n", scsi_bidi_cmnd(sc) ?
313                    "bidirectional" : sc->sc_data_direction == DMA_TO_DEVICE ?
314                    "write" : "read", conn->id, sc, sc->cmnd[0], task->itt,
315                    scsi_bufflen(sc),
316                    scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
317                    session->cmdsn, session->max_cmdsn - session->exp_cmdsn + 1);
318         return 0;
319 }
320
321 /**
322  * iscsi_complete_command - finish a task
323  * @task: iscsi cmd task
324  *
325  * Must be called with session lock.
326  * This function returns the scsi command to scsi-ml or cleans
327  * up mgmt tasks then returns the task to the pool.
328  */
329 static void iscsi_complete_command(struct iscsi_task *task)
330 {
331         struct iscsi_conn *conn = task->conn;
332         struct iscsi_session *session = conn->session;
333         struct scsi_cmnd *sc = task->sc;
334
335         list_del_init(&task->running);
336         task->state = ISCSI_TASK_COMPLETED;
337         task->sc = NULL;
338
339         if (conn->task == task)
340                 conn->task = NULL;
341         /*
342          * login task is preallocated so do not free
343          */
344         if (conn->login_task == task)
345                 return;
346
347         __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*));
348
349         if (conn->ping_task == task)
350                 conn->ping_task = NULL;
351
352         if (sc) {
353                 task->sc = NULL;
354                 /* SCSI eh reuses commands to verify us */
355                 sc->SCp.ptr = NULL;
356                 /*
357                  * queue command may call this to free the task, but
358                  * not have setup the sc callback
359                  */
360                 if (sc->scsi_done)
361                         sc->scsi_done(sc);
362         }
363 }
364
365 void __iscsi_get_task(struct iscsi_task *task)
366 {
367         atomic_inc(&task->refcount);
368 }
369 EXPORT_SYMBOL_GPL(__iscsi_get_task);
370
371 static void __iscsi_put_task(struct iscsi_task *task)
372 {
373         if (atomic_dec_and_test(&task->refcount))
374                 iscsi_complete_command(task);
375 }
376
377 void iscsi_put_task(struct iscsi_task *task)
378 {
379         struct iscsi_session *session = task->conn->session;
380
381         spin_lock_bh(&session->lock);
382         __iscsi_put_task(task);
383         spin_unlock_bh(&session->lock);
384 }
385 EXPORT_SYMBOL_GPL(iscsi_put_task);
386
387 /*
388  * session lock must be held
389  */
390 static void fail_command(struct iscsi_conn *conn, struct iscsi_task *task,
391                          int err)
392 {
393         struct scsi_cmnd *sc;
394
395         sc = task->sc;
396         if (!sc)
397                 return;
398
399         if (task->state == ISCSI_TASK_PENDING)
400                 /*
401                  * cmd never made it to the xmit thread, so we should not count
402                  * the cmd in the sequencing
403                  */
404                 conn->session->queued_cmdsn--;
405         else
406                 conn->session->tt->cleanup_task(conn, task);
407         /*
408          * Check if cleanup_task dropped the lock and the command completed,
409          */
410         if (!task->sc)
411                 return;
412
413         sc->result = err;
414         if (!scsi_bidi_cmnd(sc))
415                 scsi_set_resid(sc, scsi_bufflen(sc));
416         else {
417                 scsi_out(sc)->resid = scsi_out(sc)->length;
418                 scsi_in(sc)->resid = scsi_in(sc)->length;
419         }
420
421         if (conn->task == task)
422                 conn->task = NULL;
423         /* release ref from queuecommand */
424         __iscsi_put_task(task);
425 }
426
427 static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
428                                 struct iscsi_task *task)
429 {
430         struct iscsi_session *session = conn->session;
431         struct iscsi_hdr *hdr = (struct iscsi_hdr *)task->hdr;
432         struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
433
434         if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
435                 return -ENOTCONN;
436
437         if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) &&
438             hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
439                 nop->exp_statsn = cpu_to_be32(conn->exp_statsn);
440         /*
441          * pre-format CmdSN for outgoing PDU.
442          */
443         nop->cmdsn = cpu_to_be32(session->cmdsn);
444         if (hdr->itt != RESERVED_ITT) {
445                 hdr->itt = build_itt(task->itt, session->age);
446                 /*
447                  * TODO: We always use immediate, so we never hit this.
448                  * If we start to send tmfs or nops as non-immediate then
449                  * we should start checking the cmdsn numbers for mgmt tasks.
450                  */
451                 if (conn->c_stage == ISCSI_CONN_STARTED &&
452                     !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
453                         session->queued_cmdsn++;
454                         session->cmdsn++;
455                 }
456         }
457
458         if (session->tt->init_task)
459                 session->tt->init_task(task);
460
461         if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
462                 session->state = ISCSI_STATE_LOGGING_OUT;
463
464         list_move_tail(&task->running, &conn->mgmt_run_list);
465         debug_scsi("mgmtpdu [op 0x%x hdr->itt 0x%x datalen %d]\n",
466                    hdr->opcode & ISCSI_OPCODE_MASK, hdr->itt,
467                    task->data_count);
468         return 0;
469 }
470
471 static struct iscsi_task *
472 __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
473                       char *data, uint32_t data_size)
474 {
475         struct iscsi_session *session = conn->session;
476         struct iscsi_task *task;
477
478         if (session->state == ISCSI_STATE_TERMINATE)
479                 return NULL;
480
481         if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) ||
482             hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
483                 /*
484                  * Login and Text are sent serially, in
485                  * request-followed-by-response sequence.
486                  * Same task can be used. Same ITT must be used.
487                  * Note that login_task is preallocated at conn_create().
488                  */
489                 task = conn->login_task;
490         else {
491                 BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
492                 BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
493
494                 if (!__kfifo_get(session->cmdpool.queue,
495                                  (void*)&task, sizeof(void*)))
496                         return NULL;
497
498                 if ((hdr->opcode == (ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE)) &&
499                      hdr->ttt == RESERVED_ITT) {
500                         conn->ping_task = task;
501                         conn->last_ping = jiffies;
502                 }
503         }
504         /*
505          * released in complete pdu for task we expect a response for, and
506          * released by the lld when it has transmitted the task for
507          * pdus we do not expect a response for.
508          */
509         atomic_set(&task->refcount, 1);
510         task->conn = conn;
511         task->sc = NULL;
512
513         if (data_size) {
514                 memcpy(task->data, data, data_size);
515                 task->data_count = data_size;
516         } else
517                 task->data_count = 0;
518
519         memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
520         INIT_LIST_HEAD(&task->running);
521         list_add_tail(&task->running, &conn->mgmtqueue);
522
523         if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) {
524                 if (iscsi_prep_mgmt_task(conn, task)) {
525                         __iscsi_put_task(task);
526                         return NULL;
527                 }
528
529                 if (session->tt->xmit_task(task))
530                         task = NULL;
531
532         } else
533                 scsi_queue_work(conn->session->host, &conn->xmitwork);
534
535         return task;
536 }
537
538 int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr,
539                         char *data, uint32_t data_size)
540 {
541         struct iscsi_conn *conn = cls_conn->dd_data;
542         struct iscsi_session *session = conn->session;
543         int err = 0;
544
545         spin_lock_bh(&session->lock);
546         if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size))
547                 err = -EPERM;
548         spin_unlock_bh(&session->lock);
549         return err;
550 }
551 EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu);
552
553 /**
554  * iscsi_cmd_rsp - SCSI Command Response processing
555  * @conn: iscsi connection
556  * @hdr: iscsi header
557  * @task: scsi command task
558  * @data: cmd data buffer
559  * @datalen: len of buffer
560  *
561  * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
562  * then completes the command and task.
563  **/
564 static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
565                                struct iscsi_task *task, char *data,
566                                int datalen)
567 {
568         struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr;
569         struct iscsi_session *session = conn->session;
570         struct scsi_cmnd *sc = task->sc;
571
572         iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
573         conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
574
575         sc->result = (DID_OK << 16) | rhdr->cmd_status;
576
577         if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) {
578                 sc->result = DID_ERROR << 16;
579                 goto out;
580         }
581
582         if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) {
583                 uint16_t senselen;
584
585                 if (datalen < 2) {
586 invalid_datalen:
587                         iscsi_conn_printk(KERN_ERR,  conn,
588                                          "Got CHECK_CONDITION but invalid data "
589                                          "buffer size of %d\n", datalen);
590                         sc->result = DID_BAD_TARGET << 16;
591                         goto out;
592                 }
593
594                 senselen = get_unaligned_be16(data);
595                 if (datalen < senselen)
596                         goto invalid_datalen;
597
598                 memcpy(sc->sense_buffer, data + 2,
599                        min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
600                 debug_scsi("copied %d bytes of sense\n",
601                            min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
602         }
603
604         if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW |
605                            ISCSI_FLAG_CMD_BIDI_OVERFLOW)) {
606                 int res_count = be32_to_cpu(rhdr->bi_residual_count);
607
608                 if (scsi_bidi_cmnd(sc) && res_count > 0 &&
609                                 (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW ||
610                                  res_count <= scsi_in(sc)->length))
611                         scsi_in(sc)->resid = res_count;
612                 else
613                         sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
614         }
615
616         if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
617                            ISCSI_FLAG_CMD_OVERFLOW)) {
618                 int res_count = be32_to_cpu(rhdr->residual_count);
619
620                 if (res_count > 0 &&
621                     (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
622                      res_count <= scsi_bufflen(sc)))
623                         /* write side for bidi or uni-io set_resid */
624                         scsi_set_resid(sc, res_count);
625                 else
626                         sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
627         }
628 out:
629         debug_scsi("done [sc %lx res %d itt 0x%x]\n",
630                    (long)sc, sc->result, task->itt);
631         conn->scsirsp_pdus_cnt++;
632
633         __iscsi_put_task(task);
634 }
635
636 /**
637  * iscsi_data_in_rsp - SCSI Data-In Response processing
638  * @conn: iscsi connection
639  * @hdr:  iscsi pdu
640  * @task: scsi command task
641  **/
642 static void
643 iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
644                   struct iscsi_task *task)
645 {
646         struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr;
647         struct scsi_cmnd *sc = task->sc;
648
649         if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS))
650                 return;
651
652         sc->result = (DID_OK << 16) | rhdr->cmd_status;
653         conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
654         if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW |
655                            ISCSI_FLAG_DATA_OVERFLOW)) {
656                 int res_count = be32_to_cpu(rhdr->residual_count);
657
658                 if (res_count > 0 &&
659                     (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
660                      res_count <= scsi_in(sc)->length))
661                         scsi_in(sc)->resid = res_count;
662                 else
663                         sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
664         }
665
666         conn->scsirsp_pdus_cnt++;
667         __iscsi_put_task(task);
668 }
669
670 static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
671 {
672         struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr;
673
674         conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
675         conn->tmfrsp_pdus_cnt++;
676
677         if (conn->tmf_state != TMF_QUEUED)
678                 return;
679
680         if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
681                 conn->tmf_state = TMF_SUCCESS;
682         else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
683                 conn->tmf_state = TMF_NOT_FOUND;
684         else
685                 conn->tmf_state = TMF_FAILED;
686         wake_up(&conn->ehwait);
687 }
688
689 static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
690 {
691         struct iscsi_nopout hdr;
692         struct iscsi_task *task;
693
694         if (!rhdr && conn->ping_task)
695                 return;
696
697         memset(&hdr, 0, sizeof(struct iscsi_nopout));
698         hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE;
699         hdr.flags = ISCSI_FLAG_CMD_FINAL;
700
701         if (rhdr) {
702                 memcpy(hdr.lun, rhdr->lun, 8);
703                 hdr.ttt = rhdr->ttt;
704                 hdr.itt = RESERVED_ITT;
705         } else
706                 hdr.ttt = RESERVED_ITT;
707
708         task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
709         if (!task)
710                 iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
711 }
712
713 static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
714                                char *data, int datalen)
715 {
716         struct iscsi_reject *reject = (struct iscsi_reject *)hdr;
717         struct iscsi_hdr rejected_pdu;
718         uint32_t itt;
719
720         conn->exp_statsn = be32_to_cpu(reject->statsn) + 1;
721
722         if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) {
723                 if (ntoh24(reject->dlength) > datalen)
724                         return ISCSI_ERR_PROTO;
725
726                 if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) {
727                         memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr));
728                         itt = get_itt(rejected_pdu.itt);
729                         iscsi_conn_printk(KERN_ERR, conn,
730                                           "itt 0x%x had pdu (op 0x%x) rejected "
731                                           "due to DataDigest error.\n", itt,
732                                           rejected_pdu.opcode);
733                 }
734         }
735         return 0;
736 }
737
738 /**
739  * iscsi_itt_to_task - look up task by itt
740  * @conn: iscsi connection
741  * @itt: itt
742  *
743  * This should be used for mgmt tasks like login and nops, or if
744  * the LDD's itt space does not include the session age.
745  *
746  * The session lock must be held.
747  */
748 static struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
749 {
750         struct iscsi_session *session = conn->session;
751         uint32_t i;
752
753         if (itt == RESERVED_ITT)
754                 return NULL;
755
756         i = get_itt(itt);
757         if (i >= session->cmds_max)
758                 return NULL;
759
760         return session->cmds[i];
761 }
762
763 /**
764  * __iscsi_complete_pdu - complete pdu
765  * @conn: iscsi conn
766  * @hdr: iscsi header
767  * @data: data buffer
768  * @datalen: len of data buffer
769  *
770  * Completes pdu processing by freeing any resources allocated at
771  * queuecommand or send generic. session lock must be held and verify
772  * itt must have been called.
773  */
774 int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
775                          char *data, int datalen)
776 {
777         struct iscsi_session *session = conn->session;
778         int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
779         struct iscsi_task *task;
780         uint32_t itt;
781
782         conn->last_recv = jiffies;
783         rc = iscsi_verify_itt(conn, hdr->itt);
784         if (rc)
785                 return rc;
786
787         if (hdr->itt != RESERVED_ITT)
788                 itt = get_itt(hdr->itt);
789         else
790                 itt = ~0U;
791
792         debug_scsi("[op 0x%x cid %d itt 0x%x len %d]\n",
793                    opcode, conn->id, itt, datalen);
794
795         if (itt == ~0U) {
796                 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
797
798                 switch(opcode) {
799                 case ISCSI_OP_NOOP_IN:
800                         if (datalen) {
801                                 rc = ISCSI_ERR_PROTO;
802                                 break;
803                         }
804
805                         if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
806                                 break;
807
808                         iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
809                         break;
810                 case ISCSI_OP_REJECT:
811                         rc = iscsi_handle_reject(conn, hdr, data, datalen);
812                         break;
813                 case ISCSI_OP_ASYNC_EVENT:
814                         conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
815                         if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
816                                 rc = ISCSI_ERR_CONN_FAILED;
817                         break;
818                 default:
819                         rc = ISCSI_ERR_BAD_OPCODE;
820                         break;
821                 }
822                 goto out;
823         }
824
825         switch(opcode) {
826         case ISCSI_OP_SCSI_CMD_RSP:
827         case ISCSI_OP_SCSI_DATA_IN:
828                 task = iscsi_itt_to_ctask(conn, hdr->itt);
829                 if (!task)
830                         return ISCSI_ERR_BAD_ITT;
831                 break;
832         case ISCSI_OP_R2T:
833                 /*
834                  * LLD handles R2Ts if they need to.
835                  */
836                 return 0;
837         case ISCSI_OP_LOGOUT_RSP:
838         case ISCSI_OP_LOGIN_RSP:
839         case ISCSI_OP_TEXT_RSP:
840         case ISCSI_OP_SCSI_TMFUNC_RSP:
841         case ISCSI_OP_NOOP_IN:
842                 task = iscsi_itt_to_task(conn, hdr->itt);
843                 if (!task)
844                         return ISCSI_ERR_BAD_ITT;
845                 break;
846         default:
847                 return ISCSI_ERR_BAD_OPCODE;
848         }
849
850         switch(opcode) {
851         case ISCSI_OP_SCSI_CMD_RSP:
852                 iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
853                 break;
854         case ISCSI_OP_SCSI_DATA_IN:
855                 iscsi_data_in_rsp(conn, hdr, task);
856                 break;
857         case ISCSI_OP_LOGOUT_RSP:
858                 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
859                 if (datalen) {
860                         rc = ISCSI_ERR_PROTO;
861                         break;
862                 }
863                 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
864                 goto recv_pdu;
865         case ISCSI_OP_LOGIN_RSP:
866         case ISCSI_OP_TEXT_RSP:
867                 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
868                 /*
869                  * login related PDU's exp_statsn is handled in
870                  * userspace
871                  */
872                 goto recv_pdu;
873         case ISCSI_OP_SCSI_TMFUNC_RSP:
874                 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
875                 if (datalen) {
876                         rc = ISCSI_ERR_PROTO;
877                         break;
878                 }
879
880                 iscsi_tmf_rsp(conn, hdr);
881                 __iscsi_put_task(task);
882                 break;
883         case ISCSI_OP_NOOP_IN:
884                 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
885                 if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) {
886                         rc = ISCSI_ERR_PROTO;
887                         break;
888                 }
889                 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
890
891                 if (conn->ping_task != task)
892                         /*
893                          * If this is not in response to one of our
894                          * nops then it must be from userspace.
895                          */
896                         goto recv_pdu;
897
898                 mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout);
899                 __iscsi_put_task(task);
900                 break;
901         default:
902                 rc = ISCSI_ERR_BAD_OPCODE;
903                 break;
904         }
905
906 out:
907         return rc;
908 recv_pdu:
909         if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
910                 rc = ISCSI_ERR_CONN_FAILED;
911         __iscsi_put_task(task);
912         return rc;
913 }
914 EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
915
916 int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
917                        char *data, int datalen)
918 {
919         int rc;
920
921         spin_lock(&conn->session->lock);
922         rc = __iscsi_complete_pdu(conn, hdr, data, datalen);
923         spin_unlock(&conn->session->lock);
924         return rc;
925 }
926 EXPORT_SYMBOL_GPL(iscsi_complete_pdu);
927
928 int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
929 {
930         struct iscsi_session *session = conn->session;
931         uint32_t i;
932
933         if (itt == RESERVED_ITT)
934                 return 0;
935
936         if (((__force u32)itt & ISCSI_AGE_MASK) !=
937             (session->age << ISCSI_AGE_SHIFT)) {
938                 iscsi_conn_printk(KERN_ERR, conn,
939                                   "received itt %x expected session age (%x)\n",
940                                   (__force u32)itt, session->age);
941                 return ISCSI_ERR_BAD_ITT;
942         }
943
944         i = get_itt(itt);
945         if (i >= session->cmds_max) {
946                 iscsi_conn_printk(KERN_ERR, conn,
947                                   "received invalid itt index %u (max cmds "
948                                    "%u.\n", i, session->cmds_max);
949                 return ISCSI_ERR_BAD_ITT;
950         }
951         return 0;
952 }
953 EXPORT_SYMBOL_GPL(iscsi_verify_itt);
954
955 /**
956  * iscsi_itt_to_ctask - look up ctask by itt
957  * @conn: iscsi connection
958  * @itt: itt
959  *
960  * This should be used for cmd tasks.
961  *
962  * The session lock must be held.
963  */
964 struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
965 {
966         struct iscsi_task *task;
967
968         if (iscsi_verify_itt(conn, itt))
969                 return NULL;
970
971         task = iscsi_itt_to_task(conn, itt);
972         if (!task || !task->sc)
973                 return NULL;
974
975         if (task->sc->SCp.phase != conn->session->age) {
976                 iscsi_session_printk(KERN_ERR, conn->session,
977                                   "task's session age %d, expected %d\n",
978                                   task->sc->SCp.phase, conn->session->age);
979                 return NULL;
980         }
981
982         return task;
983 }
984 EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);
985
986 void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
987 {
988         struct iscsi_session *session = conn->session;
989         unsigned long flags;
990
991         spin_lock_irqsave(&session->lock, flags);
992         if (session->state == ISCSI_STATE_FAILED) {
993                 spin_unlock_irqrestore(&session->lock, flags);
994                 return;
995         }
996
997         if (conn->stop_stage == 0)
998                 session->state = ISCSI_STATE_FAILED;
999         spin_unlock_irqrestore(&session->lock, flags);
1000         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1001         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1002         iscsi_conn_error(conn->cls_conn, err);
1003 }
1004 EXPORT_SYMBOL_GPL(iscsi_conn_failure);
1005
1006 static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn)
1007 {
1008         struct iscsi_session *session = conn->session;
1009
1010         /*
1011          * Check for iSCSI window and take care of CmdSN wrap-around
1012          */
1013         if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
1014                 debug_scsi("iSCSI CmdSN closed. ExpCmdSn %u MaxCmdSN %u "
1015                            "CmdSN %u/%u\n", session->exp_cmdsn,
1016                            session->max_cmdsn, session->cmdsn,
1017                            session->queued_cmdsn);
1018                 return -ENOSPC;
1019         }
1020         return 0;
1021 }
1022
1023 static int iscsi_xmit_task(struct iscsi_conn *conn)
1024 {
1025         struct iscsi_task *task = conn->task;
1026         int rc;
1027
1028         __iscsi_get_task(task);
1029         spin_unlock_bh(&conn->session->lock);
1030         rc = conn->session->tt->xmit_task(task);
1031         spin_lock_bh(&conn->session->lock);
1032         __iscsi_put_task(task);
1033         if (!rc)
1034                 /* done with this task */
1035                 conn->task = NULL;
1036         return rc;
1037 }
1038
1039 /**
1040  * iscsi_requeue_task - requeue task to run from session workqueue
1041  * @task: task to requeue
1042  *
1043  * LLDs that need to run a task from the session workqueue should call
1044  * this. The session lock must be held. This should only be called
1045  * by software drivers.
1046  */
1047 void iscsi_requeue_task(struct iscsi_task *task)
1048 {
1049         struct iscsi_conn *conn = task->conn;
1050
1051         list_move_tail(&task->running, &conn->requeue);
1052         scsi_queue_work(conn->session->host, &conn->xmitwork);
1053 }
1054 EXPORT_SYMBOL_GPL(iscsi_requeue_task);
1055
1056 /**
1057  * iscsi_data_xmit - xmit any command into the scheduled connection
1058  * @conn: iscsi connection
1059  *
1060  * Notes:
1061  *      The function can return -EAGAIN in which case the caller must
1062  *      re-schedule it again later or recover. '0' return code means
1063  *      successful xmit.
1064  **/
1065 static int iscsi_data_xmit(struct iscsi_conn *conn)
1066 {
1067         int rc = 0;
1068
1069         spin_lock_bh(&conn->session->lock);
1070         if (unlikely(conn->suspend_tx)) {
1071                 debug_scsi("conn %d Tx suspended!\n", conn->id);
1072                 spin_unlock_bh(&conn->session->lock);
1073                 return -ENODATA;
1074         }
1075
1076         if (conn->task) {
1077                 rc = iscsi_xmit_task(conn);
1078                 if (rc)
1079                         goto again;
1080         }
1081
1082         /*
1083          * process mgmt pdus like nops before commands since we should
1084          * only have one nop-out as a ping from us and targets should not
1085          * overflow us with nop-ins
1086          */
1087 check_mgmt:
1088         while (!list_empty(&conn->mgmtqueue)) {
1089                 conn->task = list_entry(conn->mgmtqueue.next,
1090                                          struct iscsi_task, running);
1091                 if (iscsi_prep_mgmt_task(conn, conn->task)) {
1092                         __iscsi_put_task(conn->task);
1093                         conn->task = NULL;
1094                         continue;
1095                 }
1096                 rc = iscsi_xmit_task(conn);
1097                 if (rc)
1098                         goto again;
1099         }
1100
1101         /* process pending command queue */
1102         while (!list_empty(&conn->xmitqueue)) {
1103                 if (conn->tmf_state == TMF_QUEUED)
1104                         break;
1105
1106                 conn->task = list_entry(conn->xmitqueue.next,
1107                                          struct iscsi_task, running);
1108                 if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
1109                         fail_command(conn, conn->task, DID_IMM_RETRY << 16);
1110                         continue;
1111                 }
1112                 if (iscsi_prep_scsi_cmd_pdu(conn->task)) {
1113                         fail_command(conn, conn->task, DID_ABORT << 16);
1114                         continue;
1115                 }
1116                 rc = iscsi_xmit_task(conn);
1117                 if (rc)
1118                         goto again;
1119                 /*
1120                  * we could continuously get new task requests so
1121                  * we need to check the mgmt queue for nops that need to
1122                  * be sent to aviod starvation
1123                  */
1124                 if (!list_empty(&conn->mgmtqueue))
1125                         goto check_mgmt;
1126         }
1127
1128         while (!list_empty(&conn->requeue)) {
1129                 if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL)
1130                         break;
1131
1132                 /*
1133                  * we always do fastlogout - conn stop code will clean up.
1134                  */
1135                 if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
1136                         break;
1137
1138                 conn->task = list_entry(conn->requeue.next,
1139                                          struct iscsi_task, running);
1140                 conn->task->state = ISCSI_TASK_RUNNING;
1141                 list_move_tail(conn->requeue.next, &conn->run_list);
1142                 rc = iscsi_xmit_task(conn);
1143                 if (rc)
1144                         goto again;
1145                 if (!list_empty(&conn->mgmtqueue))
1146                         goto check_mgmt;
1147         }
1148         spin_unlock_bh(&conn->session->lock);
1149         return -ENODATA;
1150
1151 again:
1152         if (unlikely(conn->suspend_tx))
1153                 rc = -ENODATA;
1154         spin_unlock_bh(&conn->session->lock);
1155         return rc;
1156 }
1157
1158 static void iscsi_xmitworker(struct work_struct *work)
1159 {
1160         struct iscsi_conn *conn =
1161                 container_of(work, struct iscsi_conn, xmitwork);
1162         int rc;
1163         /*
1164          * serialize Xmit worker on a per-connection basis.
1165          */
1166         do {
1167                 rc = iscsi_data_xmit(conn);
1168         } while (rc >= 0 || rc == -EAGAIN);
1169 }
1170
1171 enum {
1172         FAILURE_BAD_HOST = 1,
1173         FAILURE_SESSION_FAILED,
1174         FAILURE_SESSION_FREED,
1175         FAILURE_WINDOW_CLOSED,
1176         FAILURE_OOM,
1177         FAILURE_SESSION_TERMINATE,
1178         FAILURE_SESSION_IN_RECOVERY,
1179         FAILURE_SESSION_RECOVERY_TIMEOUT,
1180         FAILURE_SESSION_LOGGING_OUT,
1181         FAILURE_SESSION_NOT_READY,
1182 };
1183
1184 int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
1185 {
1186         struct iscsi_cls_session *cls_session;
1187         struct Scsi_Host *host;
1188         int reason = 0;
1189         struct iscsi_session *session;
1190         struct iscsi_conn *conn;
1191         struct iscsi_task *task = NULL;
1192
1193         sc->scsi_done = done;
1194         sc->result = 0;
1195         sc->SCp.ptr = NULL;
1196
1197         host = sc->device->host;
1198         spin_unlock(host->host_lock);
1199
1200         cls_session = starget_to_session(scsi_target(sc->device));
1201         session = cls_session->dd_data;
1202         spin_lock(&session->lock);
1203
1204         reason = iscsi_session_chkready(cls_session);
1205         if (reason) {
1206                 sc->result = reason;
1207                 goto fault;
1208         }
1209
1210         /*
1211          * ISCSI_STATE_FAILED is a temp. state. The recovery
1212          * code will decide what is best to do with command queued
1213          * during this time
1214          */
1215         if (session->state != ISCSI_STATE_LOGGED_IN &&
1216             session->state != ISCSI_STATE_FAILED) {
1217                 /*
1218                  * to handle the race between when we set the recovery state
1219                  * and block the session we requeue here (commands could
1220                  * be entering our queuecommand while a block is starting
1221                  * up because the block code is not locked)
1222                  */
1223                 switch (session->state) {
1224                 case ISCSI_STATE_IN_RECOVERY:
1225                         reason = FAILURE_SESSION_IN_RECOVERY;
1226                         goto reject;
1227                 case ISCSI_STATE_LOGGING_OUT:
1228                         reason = FAILURE_SESSION_LOGGING_OUT;
1229                         goto reject;
1230                 case ISCSI_STATE_RECOVERY_FAILED:
1231                         reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
1232                         sc->result = DID_TRANSPORT_FAILFAST << 16;
1233                         break;
1234                 case ISCSI_STATE_TERMINATE:
1235                         reason = FAILURE_SESSION_TERMINATE;
1236                         sc->result = DID_NO_CONNECT << 16;
1237                         break;
1238                 default:
1239                         reason = FAILURE_SESSION_FREED;
1240                         sc->result = DID_NO_CONNECT << 16;
1241                 }
1242                 goto fault;
1243         }
1244
1245         conn = session->leadconn;
1246         if (!conn) {
1247                 reason = FAILURE_SESSION_FREED;
1248                 sc->result = DID_NO_CONNECT << 16;
1249                 goto fault;
1250         }
1251
1252         if (iscsi_check_cmdsn_window_closed(conn)) {
1253                 reason = FAILURE_WINDOW_CLOSED;
1254                 goto reject;
1255         }
1256
1257         if (!__kfifo_get(session->cmdpool.queue, (void*)&task,
1258                          sizeof(void*))) {
1259                 reason = FAILURE_OOM;
1260                 goto reject;
1261         }
1262         sc->SCp.phase = session->age;
1263         sc->SCp.ptr = (char *)task;
1264
1265         atomic_set(&task->refcount, 1);
1266         task->state = ISCSI_TASK_PENDING;
1267         task->conn = conn;
1268         task->sc = sc;
1269         INIT_LIST_HEAD(&task->running);
1270         list_add_tail(&task->running, &conn->xmitqueue);
1271
1272         if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) {
1273                 if (iscsi_prep_scsi_cmd_pdu(task)) {
1274                         sc->result = DID_ABORT << 16;
1275                         sc->scsi_done = NULL;
1276                         iscsi_complete_command(task);
1277                         goto fault;
1278                 }
1279                 if (session->tt->xmit_task(task)) {
1280                         sc->scsi_done = NULL;
1281                         iscsi_complete_command(task);
1282                         reason = FAILURE_SESSION_NOT_READY;
1283                         goto reject;
1284                 }
1285         } else
1286                 scsi_queue_work(session->host, &conn->xmitwork);
1287
1288         session->queued_cmdsn++;
1289         spin_unlock(&session->lock);
1290         spin_lock(host->host_lock);
1291         return 0;
1292
1293 reject:
1294         spin_unlock(&session->lock);
1295         debug_scsi("cmd 0x%x rejected (%d)\n", sc->cmnd[0], reason);
1296         spin_lock(host->host_lock);
1297         return SCSI_MLQUEUE_TARGET_BUSY;
1298
1299 fault:
1300         spin_unlock(&session->lock);
1301         debug_scsi("iscsi: cmd 0x%x is not queued (%d)\n", sc->cmnd[0], reason);
1302         if (!scsi_bidi_cmnd(sc))
1303                 scsi_set_resid(sc, scsi_bufflen(sc));
1304         else {
1305                 scsi_out(sc)->resid = scsi_out(sc)->length;
1306                 scsi_in(sc)->resid = scsi_in(sc)->length;
1307         }
1308         done(sc);
1309         spin_lock(host->host_lock);
1310         return 0;
1311 }
1312 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
1313
1314 int iscsi_change_queue_depth(struct scsi_device *sdev, int depth)
1315 {
1316         if (depth > ISCSI_MAX_CMD_PER_LUN)
1317                 depth = ISCSI_MAX_CMD_PER_LUN;
1318         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
1319         return sdev->queue_depth;
1320 }
1321 EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);
1322
1323 void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
1324 {
1325         struct iscsi_session *session = cls_session->dd_data;
1326
1327         spin_lock_bh(&session->lock);
1328         if (session->state != ISCSI_STATE_LOGGED_IN) {
1329                 session->state = ISCSI_STATE_RECOVERY_FAILED;
1330                 if (session->leadconn)
1331                         wake_up(&session->leadconn->ehwait);
1332         }
1333         spin_unlock_bh(&session->lock);
1334 }
1335 EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
1336
1337 int iscsi_eh_host_reset(struct scsi_cmnd *sc)
1338 {
1339         struct iscsi_cls_session *cls_session;
1340         struct iscsi_session *session;
1341         struct iscsi_conn *conn;
1342
1343         cls_session = starget_to_session(scsi_target(sc->device));
1344         session = cls_session->dd_data;
1345         conn = session->leadconn;
1346
1347         mutex_lock(&session->eh_mutex);
1348         spin_lock_bh(&session->lock);
1349         if (session->state == ISCSI_STATE_TERMINATE) {
1350 failed:
1351                 debug_scsi("failing host reset: session terminated "
1352                            "[CID %d age %d]\n", conn->id, session->age);
1353                 spin_unlock_bh(&session->lock);
1354                 mutex_unlock(&session->eh_mutex);
1355                 return FAILED;
1356         }
1357
1358         spin_unlock_bh(&session->lock);
1359         mutex_unlock(&session->eh_mutex);
1360         /*
1361          * we drop the lock here but the leadconn cannot be destoyed while
1362          * we are in the scsi eh
1363          */
1364         iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1365
1366         debug_scsi("iscsi_eh_host_reset wait for relogin\n");
1367         wait_event_interruptible(conn->ehwait,
1368                                  session->state == ISCSI_STATE_TERMINATE ||
1369                                  session->state == ISCSI_STATE_LOGGED_IN ||
1370                                  session->state == ISCSI_STATE_RECOVERY_FAILED);
1371         if (signal_pending(current))
1372                 flush_signals(current);
1373
1374         mutex_lock(&session->eh_mutex);
1375         spin_lock_bh(&session->lock);
1376         if (session->state == ISCSI_STATE_LOGGED_IN)
1377                 iscsi_session_printk(KERN_INFO, session,
1378                                      "host reset succeeded\n");
1379         else
1380                 goto failed;
1381         spin_unlock_bh(&session->lock);
1382         mutex_unlock(&session->eh_mutex);
1383         return SUCCESS;
1384 }
1385 EXPORT_SYMBOL_GPL(iscsi_eh_host_reset);
1386
1387 static void iscsi_tmf_timedout(unsigned long data)
1388 {
1389         struct iscsi_conn *conn = (struct iscsi_conn *)data;
1390         struct iscsi_session *session = conn->session;
1391
1392         spin_lock(&session->lock);
1393         if (conn->tmf_state == TMF_QUEUED) {
1394                 conn->tmf_state = TMF_TIMEDOUT;
1395                 debug_scsi("tmf timedout\n");
1396                 /* unblock eh_abort() */
1397                 wake_up(&conn->ehwait);
1398         }
1399         spin_unlock(&session->lock);
1400 }
1401
1402 static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
1403                                    struct iscsi_tm *hdr, int age,
1404                                    int timeout)
1405 {
1406         struct iscsi_session *session = conn->session;
1407         struct iscsi_task *task;
1408
1409         task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
1410                                       NULL, 0);
1411         if (!task) {
1412                 spin_unlock_bh(&session->lock);
1413                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1414                 spin_lock_bh(&session->lock);
1415                 debug_scsi("tmf exec failure\n");
1416                 return -EPERM;
1417         }
1418         conn->tmfcmd_pdus_cnt++;
1419         conn->tmf_timer.expires = timeout * HZ + jiffies;
1420         conn->tmf_timer.function = iscsi_tmf_timedout;
1421         conn->tmf_timer.data = (unsigned long)conn;
1422         add_timer(&conn->tmf_timer);
1423         debug_scsi("tmf set timeout\n");
1424
1425         spin_unlock_bh(&session->lock);
1426         mutex_unlock(&session->eh_mutex);
1427
1428         /*
1429          * block eh thread until:
1430          *
1431          * 1) tmf response
1432          * 2) tmf timeout
1433          * 3) session is terminated or restarted or userspace has
1434          * given up on recovery
1435          */
1436         wait_event_interruptible(conn->ehwait, age != session->age ||
1437                                  session->state != ISCSI_STATE_LOGGED_IN ||
1438                                  conn->tmf_state != TMF_QUEUED);
1439         if (signal_pending(current))
1440                 flush_signals(current);
1441         del_timer_sync(&conn->tmf_timer);
1442
1443         mutex_lock(&session->eh_mutex);
1444         spin_lock_bh(&session->lock);
1445         /* if the session drops it will clean up the task */
1446         if (age != session->age ||
1447             session->state != ISCSI_STATE_LOGGED_IN)
1448                 return -ENOTCONN;
1449         return 0;
1450 }
1451
1452 /*
1453  * Fail commands. session lock held and recv side suspended and xmit
1454  * thread flushed
1455  */
1456 static void fail_all_commands(struct iscsi_conn *conn, unsigned lun,
1457                               int error)
1458 {
1459         struct iscsi_task *task, *tmp;
1460
1461         if (conn->task && (conn->task->sc->device->lun == lun || lun == -1))
1462                 conn->task = NULL;
1463
1464         /* flush pending */
1465         list_for_each_entry_safe(task, tmp, &conn->xmitqueue, running) {
1466                 if (lun == task->sc->device->lun || lun == -1) {
1467                         debug_scsi("failing pending sc %p itt 0x%x\n",
1468                                    task->sc, task->itt);
1469                         fail_command(conn, task, error << 16);
1470                 }
1471         }
1472
1473         list_for_each_entry_safe(task, tmp, &conn->requeue, running) {
1474                 if (lun == task->sc->device->lun || lun == -1) {
1475                         debug_scsi("failing requeued sc %p itt 0x%x\n",
1476                                    task->sc, task->itt);
1477                         fail_command(conn, task, error << 16);
1478                 }
1479         }
1480
1481         /* fail all other running */
1482         list_for_each_entry_safe(task, tmp, &conn->run_list, running) {
1483                 if (lun == task->sc->device->lun || lun == -1) {
1484                         debug_scsi("failing in progress sc %p itt 0x%x\n",
1485                                    task->sc, task->itt);
1486                         fail_command(conn, task, error << 16);
1487                 }
1488         }
1489 }
1490
1491 void iscsi_suspend_tx(struct iscsi_conn *conn)
1492 {
1493         set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1494         if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD))
1495                 scsi_flush_work(conn->session->host);
1496 }
1497 EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
1498
1499 static void iscsi_start_tx(struct iscsi_conn *conn)
1500 {
1501         clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1502         if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD))
1503                 scsi_queue_work(conn->session->host, &conn->xmitwork);
1504 }
1505
1506 static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
1507 {
1508         struct iscsi_cls_session *cls_session;
1509         struct iscsi_session *session;
1510         struct iscsi_conn *conn;
1511         enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1512
1513         cls_session = starget_to_session(scsi_target(scmd->device));
1514         session = cls_session->dd_data;
1515
1516         debug_scsi("scsi cmd %p timedout\n", scmd);
1517
1518         spin_lock(&session->lock);
1519         if (session->state != ISCSI_STATE_LOGGED_IN) {
1520                 /*
1521                  * We are probably in the middle of iscsi recovery so let
1522                  * that complete and handle the error.
1523                  */
1524                 rc = BLK_EH_RESET_TIMER;
1525                 goto done;
1526         }
1527
1528         conn = session->leadconn;
1529         if (!conn) {
1530                 /* In the middle of shuting down */
1531                 rc = BLK_EH_RESET_TIMER;
1532                 goto done;
1533         }
1534
1535         if (!conn->recv_timeout && !conn->ping_timeout)
1536                 goto done;
1537         /*
1538          * if the ping timedout then we are in the middle of cleaning up
1539          * and can let the iscsi eh handle it
1540          */
1541         if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) +
1542                             (conn->ping_timeout * HZ), jiffies))
1543                 rc = BLK_EH_RESET_TIMER;
1544         /*
1545          * if we are about to check the transport then give the command
1546          * more time
1547          */
1548         if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ),
1549                            jiffies))
1550                 rc = BLK_EH_RESET_TIMER;
1551         /* if in the middle of checking the transport then give us more time */
1552         if (conn->ping_task)
1553                 rc = BLK_EH_RESET_TIMER;
1554 done:
1555         spin_unlock(&session->lock);
1556         debug_scsi("return %s\n", rc == BLK_EH_RESET_TIMER ?
1557                                         "timer reset" : "nh");
1558         return rc;
1559 }
1560
1561 static void iscsi_check_transport_timeouts(unsigned long data)
1562 {
1563         struct iscsi_conn *conn = (struct iscsi_conn *)data;
1564         struct iscsi_session *session = conn->session;
1565         unsigned long recv_timeout, next_timeout = 0, last_recv;
1566
1567         spin_lock(&session->lock);
1568         if (session->state != ISCSI_STATE_LOGGED_IN)
1569                 goto done;
1570
1571         recv_timeout = conn->recv_timeout;
1572         if (!recv_timeout)
1573                 goto done;
1574
1575         recv_timeout *= HZ;
1576         last_recv = conn->last_recv;
1577         if (conn->ping_task &&
1578             time_before_eq(conn->last_ping + (conn->ping_timeout * HZ),
1579                            jiffies)) {
1580                 iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
1581                                   "expired, last rx %lu, last ping %lu, "
1582                                   "now %lu\n", conn->ping_timeout, last_recv,
1583                                   conn->last_ping, jiffies);
1584                 spin_unlock(&session->lock);
1585                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1586                 return;
1587         }
1588
1589         if (time_before_eq(last_recv + recv_timeout, jiffies)) {
1590                 /* send a ping to try to provoke some traffic */
1591                 debug_scsi("Sending nopout as ping on conn %p\n", conn);
1592                 iscsi_send_nopout(conn, NULL);
1593                 next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
1594         } else
1595                 next_timeout = last_recv + recv_timeout;
1596
1597         debug_scsi("Setting next tmo %lu\n", next_timeout);
1598         mod_timer(&conn->transport_timer, next_timeout);
1599 done:
1600         spin_unlock(&session->lock);
1601 }
1602
1603 static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
1604                                       struct iscsi_tm *hdr)
1605 {
1606         memset(hdr, 0, sizeof(*hdr));
1607         hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
1608         hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK;
1609         hdr->flags |= ISCSI_FLAG_CMD_FINAL;
1610         memcpy(hdr->lun, task->hdr->lun, sizeof(hdr->lun));
1611         hdr->rtt = task->hdr->itt;
1612         hdr->refcmdsn = task->hdr->cmdsn;
1613 }
1614
1615 int iscsi_eh_abort(struct scsi_cmnd *sc)
1616 {
1617         struct iscsi_cls_session *cls_session;
1618         struct iscsi_session *session;
1619         struct iscsi_conn *conn;
1620         struct iscsi_task *task;
1621         struct iscsi_tm *hdr;
1622         int rc, age;
1623
1624         cls_session = starget_to_session(scsi_target(sc->device));
1625         session = cls_session->dd_data;
1626
1627         mutex_lock(&session->eh_mutex);
1628         spin_lock_bh(&session->lock);
1629         /*
1630          * if session was ISCSI_STATE_IN_RECOVERY then we may not have
1631          * got the command.
1632          */
1633         if (!sc->SCp.ptr) {
1634                 debug_scsi("sc never reached iscsi layer or it completed.\n");
1635                 spin_unlock_bh(&session->lock);
1636                 mutex_unlock(&session->eh_mutex);
1637                 return SUCCESS;
1638         }
1639
1640         /*
1641          * If we are not logged in or we have started a new session
1642          * then let the host reset code handle this
1643          */
1644         if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
1645             sc->SCp.phase != session->age) {
1646                 spin_unlock_bh(&session->lock);
1647                 mutex_unlock(&session->eh_mutex);
1648                 return FAILED;
1649         }
1650
1651         conn = session->leadconn;
1652         conn->eh_abort_cnt++;
1653         age = session->age;
1654
1655         task = (struct iscsi_task *)sc->SCp.ptr;
1656         debug_scsi("aborting [sc %p itt 0x%x]\n", sc, task->itt);
1657
1658         /* task completed before time out */
1659         if (!task->sc) {
1660                 debug_scsi("sc completed while abort in progress\n");
1661                 goto success;
1662         }
1663
1664         if (task->state == ISCSI_TASK_PENDING) {
1665                 fail_command(conn, task, DID_ABORT << 16);
1666                 goto success;
1667         }
1668
1669         /* only have one tmf outstanding at a time */
1670         if (conn->tmf_state != TMF_INITIAL)
1671                 goto failed;
1672         conn->tmf_state = TMF_QUEUED;
1673
1674         hdr = &conn->tmhdr;
1675         iscsi_prep_abort_task_pdu(task, hdr);
1676
1677         if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) {
1678                 rc = FAILED;
1679                 goto failed;
1680         }
1681
1682         switch (conn->tmf_state) {
1683         case TMF_SUCCESS:
1684                 spin_unlock_bh(&session->lock);
1685                 /*
1686                  * stop tx side incase the target had sent a abort rsp but
1687                  * the initiator was still writing out data.
1688                  */
1689                 iscsi_suspend_tx(conn);
1690                 /*
1691                  * we do not stop the recv side because targets have been
1692                  * good and have never sent us a successful tmf response
1693                  * then sent more data for the cmd.
1694                  */
1695                 spin_lock(&session->lock);
1696                 fail_command(conn, task, DID_ABORT << 16);
1697                 conn->tmf_state = TMF_INITIAL;
1698                 spin_unlock(&session->lock);
1699                 iscsi_start_tx(conn);
1700                 goto success_unlocked;
1701         case TMF_TIMEDOUT:
1702                 spin_unlock_bh(&session->lock);
1703                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1704                 goto failed_unlocked;
1705         case TMF_NOT_FOUND:
1706                 if (!sc->SCp.ptr) {
1707                         conn->tmf_state = TMF_INITIAL;
1708                         /* task completed before tmf abort response */
1709                         debug_scsi("sc completed while abort in progress\n");
1710                         goto success;
1711                 }
1712                 /* fall through */
1713         default:
1714                 conn->tmf_state = TMF_INITIAL;
1715                 goto failed;
1716         }
1717
1718 success:
1719         spin_unlock_bh(&session->lock);
1720 success_unlocked:
1721         debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, task->itt);
1722         mutex_unlock(&session->eh_mutex);
1723         return SUCCESS;
1724
1725 failed:
1726         spin_unlock_bh(&session->lock);
1727 failed_unlocked:
1728         debug_scsi("abort failed [sc %p itt 0x%x]\n", sc,
1729                     task ? task->itt : 0);
1730         mutex_unlock(&session->eh_mutex);
1731         return FAILED;
1732 }
1733 EXPORT_SYMBOL_GPL(iscsi_eh_abort);
1734
1735 static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
1736 {
1737         memset(hdr, 0, sizeof(*hdr));
1738         hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
1739         hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK;
1740         hdr->flags |= ISCSI_FLAG_CMD_FINAL;
1741         int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
1742         hdr->rtt = RESERVED_ITT;
1743 }
1744
1745 int iscsi_eh_device_reset(struct scsi_cmnd *sc)
1746 {
1747         struct iscsi_cls_session *cls_session;
1748         struct iscsi_session *session;
1749         struct iscsi_conn *conn;
1750         struct iscsi_tm *hdr;
1751         int rc = FAILED;
1752
1753         cls_session = starget_to_session(scsi_target(sc->device));
1754         session = cls_session->dd_data;
1755
1756         debug_scsi("LU Reset [sc %p lun %u]\n", sc, sc->device->lun);
1757
1758         mutex_lock(&session->eh_mutex);
1759         spin_lock_bh(&session->lock);
1760         /*
1761          * Just check if we are not logged in. We cannot check for
1762          * the phase because the reset could come from a ioctl.
1763          */
1764         if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
1765                 goto unlock;
1766         conn = session->leadconn;
1767
1768         /* only have one tmf outstanding at a time */
1769         if (conn->tmf_state != TMF_INITIAL)
1770                 goto unlock;
1771         conn->tmf_state = TMF_QUEUED;
1772
1773         hdr = &conn->tmhdr;
1774         iscsi_prep_lun_reset_pdu(sc, hdr);
1775
1776         if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
1777                                     session->lu_reset_timeout)) {
1778                 rc = FAILED;
1779                 goto unlock;
1780         }
1781
1782         switch (conn->tmf_state) {
1783         case TMF_SUCCESS:
1784                 break;
1785         case TMF_TIMEDOUT:
1786                 spin_unlock_bh(&session->lock);
1787                 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1788                 goto done;
1789         default:
1790                 conn->tmf_state = TMF_INITIAL;
1791                 goto unlock;
1792         }
1793
1794         rc = SUCCESS;
1795         spin_unlock_bh(&session->lock);
1796
1797         iscsi_suspend_tx(conn);
1798
1799         spin_lock(&session->lock);
1800         fail_all_commands(conn, sc->device->lun, DID_ERROR);
1801         conn->tmf_state = TMF_INITIAL;
1802         spin_unlock(&session->lock);
1803
1804         iscsi_start_tx(conn);
1805         goto done;
1806
1807 unlock:
1808         spin_unlock_bh(&session->lock);
1809 done:
1810         debug_scsi("iscsi_eh_device_reset %s\n",
1811                   rc == SUCCESS ? "SUCCESS" : "FAILED");
1812         mutex_unlock(&session->eh_mutex);
1813         return rc;
1814 }
1815 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);
1816
1817 /*
1818  * Pre-allocate a pool of @max items of @item_size. By default, the pool
1819  * should be accessed via kfifo_{get,put} on q->queue.
1820  * Optionally, the caller can obtain the array of object pointers
1821  * by passing in a non-NULL @items pointer
1822  */
1823 int
1824 iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
1825 {
1826         int i, num_arrays = 1;
1827
1828         memset(q, 0, sizeof(*q));
1829
1830         q->max = max;
1831
1832         /* If the user passed an items pointer, he wants a copy of
1833          * the array. */
1834         if (items)
1835                 num_arrays++;
1836         q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL);
1837         if (q->pool == NULL)
1838                 goto enomem;
1839
1840         q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
1841                               GFP_KERNEL, NULL);
1842         if (q->queue == ERR_PTR(-ENOMEM))
1843                 goto enomem;
1844
1845         for (i = 0; i < max; i++) {
1846                 q->pool[i] = kzalloc(item_size, GFP_KERNEL);
1847                 if (q->pool[i] == NULL) {
1848                         q->max = i;
1849                         goto enomem;
1850                 }
1851                 __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
1852         }
1853
1854         if (items) {
1855                 *items = q->pool + max;
1856                 memcpy(*items, q->pool, max * sizeof(void *));
1857         }
1858
1859         return 0;
1860
1861 enomem:
1862         iscsi_pool_free(q);
1863         return -ENOMEM;
1864 }
1865 EXPORT_SYMBOL_GPL(iscsi_pool_init);
1866
1867 void iscsi_pool_free(struct iscsi_pool *q)
1868 {
1869         int i;
1870
1871         for (i = 0; i < q->max; i++)
1872                 kfree(q->pool[i]);
1873         if (q->pool)
1874                 kfree(q->pool);
1875 }
1876 EXPORT_SYMBOL_GPL(iscsi_pool_free);
1877
1878 /**
1879  * iscsi_host_add - add host to system
1880  * @shost: scsi host
1881  * @pdev: parent device
1882  *
1883  * This should be called by partial offload and software iscsi drivers
1884  * to add a host to the system.
1885  */
1886 int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev)
1887 {
1888         if (!shost->can_queue)
1889                 shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;
1890
1891         return scsi_add_host(shost, pdev);
1892 }
1893 EXPORT_SYMBOL_GPL(iscsi_host_add);
1894
1895 /**
1896  * iscsi_host_alloc - allocate a host and driver data
1897  * @sht: scsi host template
1898  * @dd_data_size: driver host data size
1899  * @qdepth: default device queue depth
1900  *
1901  * This should be called by partial offload and software iscsi drivers.
1902  * To access the driver specific memory use the iscsi_host_priv() macro.
1903  */
1904 struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht,
1905                                    int dd_data_size, uint16_t qdepth)
1906 {
1907         struct Scsi_Host *shost;
1908
1909         shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
1910         if (!shost)
1911                 return NULL;
1912         shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
1913
1914         if (qdepth > ISCSI_MAX_CMD_PER_LUN || qdepth < 1) {
1915                 if (qdepth != 0)
1916                         printk(KERN_ERR "iscsi: invalid queue depth of %d. "
1917                                "Queue depth must be between 1 and %d.\n",
1918                                qdepth, ISCSI_MAX_CMD_PER_LUN);
1919                 qdepth = ISCSI_DEF_CMD_PER_LUN;
1920         }
1921         shost->cmd_per_lun = qdepth;
1922         return shost;
1923 }
1924 EXPORT_SYMBOL_GPL(iscsi_host_alloc);
1925
1926 /**
1927  * iscsi_host_remove - remove host and sessions
1928  * @shost: scsi host
1929  *
1930  * This will also remove any sessions attached to the host, but if userspace
1931  * is managing the session at the same time this will break. TODO: add
1932  * refcounting to the netlink iscsi interface so a rmmod or host hot unplug
1933  * does not remove the memory from under us.
1934  */
1935 void iscsi_host_remove(struct Scsi_Host *shost)
1936 {
1937         iscsi_host_for_each_session(shost, iscsi_session_teardown);
1938         scsi_remove_host(shost);
1939 }
1940 EXPORT_SYMBOL_GPL(iscsi_host_remove);
1941
1942 void iscsi_host_free(struct Scsi_Host *shost)
1943 {
1944         struct iscsi_host *ihost = shost_priv(shost);
1945
1946         kfree(ihost->netdev);
1947         kfree(ihost->hwaddress);
1948         kfree(ihost->initiatorname);
1949         scsi_host_put(shost);
1950 }
1951 EXPORT_SYMBOL_GPL(iscsi_host_free);
1952
1953 /**
1954  * iscsi_session_setup - create iscsi cls session and host and session
1955  * @iscsit: iscsi transport template
1956  * @shost: scsi host
1957  * @cmds_max: session can queue
1958  * @cmd_task_size: LLD task private data size
1959  * @initial_cmdsn: initial CmdSN
1960  *
1961  * This can be used by software iscsi_transports that allocate
1962  * a session per scsi host.
1963  *
1964  * Callers should set cmds_max to the largest total numer (mgmt + scsi) of
1965  * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks
1966  * for nop handling and login/logout requests.
1967  */
1968 struct iscsi_cls_session *
1969 iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
1970                     uint16_t cmds_max, int cmd_task_size,
1971                     uint32_t initial_cmdsn, unsigned int id)
1972 {
1973         struct iscsi_session *session;
1974         struct iscsi_cls_session *cls_session;
1975         int cmd_i, scsi_cmds, total_cmds = cmds_max;
1976
1977         if (!total_cmds)
1978                 total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
1979         /*
1980          * The iscsi layer needs some tasks for nop handling and tmfs,
1981          * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX
1982          * + 1 command for scsi IO.
1983          */
1984         if (total_cmds < ISCSI_TOTAL_CMDS_MIN) {
1985                 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
1986                        "must be a power of two that is at least %d.\n",
1987                        total_cmds, ISCSI_TOTAL_CMDS_MIN);
1988                 return NULL;
1989         }
1990
1991         if (total_cmds > ISCSI_TOTAL_CMDS_MAX) {
1992                 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
1993                        "must be a power of 2 less than or equal to %d.\n",
1994                        cmds_max, ISCSI_TOTAL_CMDS_MAX);
1995                 total_cmds = ISCSI_TOTAL_CMDS_MAX;
1996         }
1997
1998         if (!is_power_of_2(total_cmds)) {
1999                 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
2000                        "must be a power of 2.\n", total_cmds);
2001                 total_cmds = rounddown_pow_of_two(total_cmds);
2002                 if (total_cmds < ISCSI_TOTAL_CMDS_MIN)
2003                         return NULL;
2004                 printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n",
2005                        total_cmds);
2006         }
2007         scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
2008
2009         cls_session = iscsi_alloc_session(shost, iscsit,
2010                                           sizeof(struct iscsi_session));
2011         if (!cls_session)
2012                 return NULL;
2013         session = cls_session->dd_data;
2014         session->cls_session = cls_session;
2015         session->host = shost;
2016         session->state = ISCSI_STATE_FREE;
2017         session->fast_abort = 1;
2018         session->lu_reset_timeout = 15;
2019         session->abort_timeout = 10;
2020         session->scsi_cmds_max = scsi_cmds;
2021         session->cmds_max = total_cmds;
2022         session->queued_cmdsn = session->cmdsn = initial_cmdsn;
2023         session->exp_cmdsn = initial_cmdsn + 1;
2024         session->max_cmdsn = initial_cmdsn + 1;
2025         session->max_r2t = 1;
2026         session->tt = iscsit;
2027         mutex_init(&session->eh_mutex);
2028         spin_lock_init(&session->lock);
2029
2030         /* initialize SCSI PDU commands pool */
2031         if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
2032                             (void***)&session->cmds,
2033                             cmd_task_size + sizeof(struct iscsi_task)))
2034                 goto cmdpool_alloc_fail;
2035
2036         /* pre-format cmds pool with ITT */
2037         for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
2038                 struct iscsi_task *task = session->cmds[cmd_i];
2039
2040                 if (cmd_task_size)
2041                         task->dd_data = &task[1];
2042                 task->itt = cmd_i;
2043                 INIT_LIST_HEAD(&task->running);
2044         }
2045
2046         if (!try_module_get(iscsit->owner))
2047                 goto module_get_fail;
2048
2049         if (iscsi_add_session(cls_session, id))
2050                 goto cls_session_fail;
2051         return cls_session;
2052
2053 cls_session_fail:
2054         module_put(iscsit->owner);
2055 module_get_fail:
2056         iscsi_pool_free(&session->cmdpool);
2057 cmdpool_alloc_fail:
2058         iscsi_free_session(cls_session);
2059         return NULL;
2060 }
2061 EXPORT_SYMBOL_GPL(iscsi_session_setup);
2062
2063 /**
2064  * iscsi_session_teardown - destroy session, host, and cls_session
2065  * @cls_session: iscsi session
2066  *
2067  * The driver must have called iscsi_remove_session before
2068  * calling this.
2069  */
2070 void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
2071 {
2072         struct iscsi_session *session = cls_session->dd_data;
2073         struct module *owner = cls_session->transport->owner;
2074
2075         iscsi_pool_free(&session->cmdpool);
2076
2077         kfree(session->password);
2078         kfree(session->password_in);
2079         kfree(session->username);
2080         kfree(session->username_in);
2081         kfree(session->targetname);
2082         kfree(session->initiatorname);
2083         kfree(session->ifacename);
2084
2085         iscsi_destroy_session(cls_session);
2086         module_put(owner);
2087 }
2088 EXPORT_SYMBOL_GPL(iscsi_session_teardown);
2089
2090 /**
2091  * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
2092  * @cls_session: iscsi_cls_session
2093  * @dd_size: private driver data size
2094  * @conn_idx: cid
2095  */
2096 struct iscsi_cls_conn *
2097 iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
2098                  uint32_t conn_idx)
2099 {
2100         struct iscsi_session *session = cls_session->dd_data;
2101         struct iscsi_conn *conn;
2102         struct iscsi_cls_conn *cls_conn;
2103         char *data;
2104
2105         cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
2106                                      conn_idx);
2107         if (!cls_conn)
2108                 return NULL;
2109         conn = cls_conn->dd_data;
2110         memset(conn, 0, sizeof(*conn) + dd_size);
2111
2112         conn->dd_data = cls_conn->dd_data + sizeof(*conn);
2113         conn->session = session;
2114         conn->cls_conn = cls_conn;
2115         conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
2116         conn->id = conn_idx;
2117         conn->exp_statsn = 0;
2118         conn->tmf_state = TMF_INITIAL;
2119
2120         init_timer(&conn->transport_timer);
2121         conn->transport_timer.data = (unsigned long)conn;
2122         conn->transport_timer.function = iscsi_check_transport_timeouts;
2123
2124         INIT_LIST_HEAD(&conn->run_list);
2125         INIT_LIST_HEAD(&conn->mgmt_run_list);
2126         INIT_LIST_HEAD(&conn->mgmtqueue);
2127         INIT_LIST_HEAD(&conn->xmitqueue);
2128         INIT_LIST_HEAD(&conn->requeue);
2129         INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
2130
2131         /* allocate login_task used for the login/text sequences */
2132         spin_lock_bh(&session->lock);
2133         if (!__kfifo_get(session->cmdpool.queue,
2134                          (void*)&conn->login_task,
2135                          sizeof(void*))) {
2136                 spin_unlock_bh(&session->lock);
2137                 goto login_task_alloc_fail;
2138         }
2139         spin_unlock_bh(&session->lock);
2140
2141         data = kmalloc(ISCSI_DEF_MAX_RECV_SEG_LEN, GFP_KERNEL);
2142         if (!data)
2143                 goto login_task_data_alloc_fail;
2144         conn->login_task->data = conn->data = data;
2145
2146         init_timer(&conn->tmf_timer);
2147         init_waitqueue_head(&conn->ehwait);
2148
2149         return cls_conn;
2150
2151 login_task_data_alloc_fail:
2152         __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
2153                     sizeof(void*));
2154 login_task_alloc_fail:
2155         iscsi_destroy_conn(cls_conn);
2156         return NULL;
2157 }
2158 EXPORT_SYMBOL_GPL(iscsi_conn_setup);
2159
2160 /**
2161  * iscsi_conn_teardown - teardown iscsi connection
2162  * cls_conn: iscsi class connection
2163  *
2164  * TODO: we may need to make this into a two step process
2165  * like scsi-mls remove + put host
2166  */
2167 void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
2168 {
2169         struct iscsi_conn *conn = cls_conn->dd_data;
2170         struct iscsi_session *session = conn->session;
2171         unsigned long flags;
2172
2173         del_timer_sync(&conn->transport_timer);
2174
2175         spin_lock_bh(&session->lock);
2176         conn->c_stage = ISCSI_CONN_CLEANUP_WAIT;
2177         if (session->leadconn == conn) {
2178                 /*
2179                  * leading connection? then give up on recovery.
2180                  */
2181                 session->state = ISCSI_STATE_TERMINATE;
2182                 wake_up(&conn->ehwait);
2183         }
2184         spin_unlock_bh(&session->lock);
2185
2186         /*
2187          * Block until all in-progress commands for this connection
2188          * time out or fail.
2189          */
2190         for (;;) {
2191                 spin_lock_irqsave(session->host->host_lock, flags);
2192                 if (!session->host->host_busy) { /* OK for ERL == 0 */
2193                         spin_unlock_irqrestore(session->host->host_lock, flags);
2194                         break;
2195                 }
2196                 spin_unlock_irqrestore(session->host->host_lock, flags);
2197                 msleep_interruptible(500);
2198                 iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): "
2199                                   "host_busy %d host_failed %d\n",
2200                                   session->host->host_busy,
2201                                   session->host->host_failed);
2202                 /*
2203                  * force eh_abort() to unblock
2204                  */
2205                 wake_up(&conn->ehwait);
2206         }
2207
2208         /* flush queued up work because we free the connection below */
2209         iscsi_suspend_tx(conn);
2210
2211         spin_lock_bh(&session->lock);
2212         kfree(conn->data);
2213         kfree(conn->persistent_address);
2214         __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
2215                     sizeof(void*));
2216         if (session->leadconn == conn)
2217                 session->leadconn = NULL;
2218         spin_unlock_bh(&session->lock);
2219
2220         iscsi_destroy_conn(cls_conn);
2221 }
2222 EXPORT_SYMBOL_GPL(iscsi_conn_teardown);
2223
2224 int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
2225 {
2226         struct iscsi_conn *conn = cls_conn->dd_data;
2227         struct iscsi_session *session = conn->session;
2228
2229         if (!session) {
2230                 iscsi_conn_printk(KERN_ERR, conn,
2231                                   "can't start unbound connection\n");
2232                 return -EPERM;
2233         }
2234
2235         if ((session->imm_data_en || !session->initial_r2t_en) &&
2236              session->first_burst > session->max_burst) {
2237                 iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
2238                                   "first_burst %d max_burst %d\n",
2239                                   session->first_burst, session->max_burst);
2240                 return -EINVAL;
2241         }
2242
2243         if (conn->ping_timeout && !conn->recv_timeout) {
2244                 iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
2245                                   "zero. Using 5 seconds\n.");
2246                 conn->recv_timeout = 5;
2247         }
2248
2249         if (conn->recv_timeout && !conn->ping_timeout) {
2250                 iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
2251                                   "zero. Using 5 seconds.\n");
2252                 conn->ping_timeout = 5;
2253         }
2254
2255         spin_lock_bh(&session->lock);
2256         conn->c_stage = ISCSI_CONN_STARTED;
2257         session->state = ISCSI_STATE_LOGGED_IN;
2258         session->queued_cmdsn = session->cmdsn;
2259
2260         conn->last_recv = jiffies;
2261         conn->last_ping = jiffies;
2262         if (conn->recv_timeout && conn->ping_timeout)
2263                 mod_timer(&conn->transport_timer,
2264                           jiffies + (conn->recv_timeout * HZ));
2265
2266         switch(conn->stop_stage) {
2267         case STOP_CONN_RECOVER:
2268                 /*
2269                  * unblock eh_abort() if it is blocked. re-try all
2270                  * commands after successful recovery
2271                  */
2272                 conn->stop_stage = 0;
2273                 conn->tmf_state = TMF_INITIAL;
2274                 session->age++;
2275                 if (session->age == 16)
2276                         session->age = 0;
2277                 break;
2278         case STOP_CONN_TERM:
2279                 conn->stop_stage = 0;
2280                 break;
2281         default:
2282                 break;
2283         }
2284         spin_unlock_bh(&session->lock);
2285
2286         iscsi_unblock_session(session->cls_session);
2287         wake_up(&conn->ehwait);
2288         return 0;
2289 }
2290 EXPORT_SYMBOL_GPL(iscsi_conn_start);
2291
2292 static void
2293 flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn)
2294 {
2295         struct iscsi_task *task, *tmp;
2296
2297         /* handle pending */
2298         list_for_each_entry_safe(task, tmp, &conn->mgmtqueue, running) {
2299                 debug_scsi("flushing pending mgmt task itt 0x%x\n", task->itt);
2300                 /* release ref from prep task */
2301                 __iscsi_put_task(task);
2302         }
2303
2304         /* handle running */
2305         list_for_each_entry_safe(task, tmp, &conn->mgmt_run_list, running) {
2306                 debug_scsi("flushing running mgmt task itt 0x%x\n", task->itt);
2307                 /* release ref from prep task */
2308                 __iscsi_put_task(task);
2309         }
2310
2311         conn->task = NULL;
2312 }
2313
2314 static void iscsi_start_session_recovery(struct iscsi_session *session,
2315                                          struct iscsi_conn *conn, int flag)
2316 {
2317         int old_stop_stage;
2318
2319         del_timer_sync(&conn->transport_timer);
2320
2321         mutex_lock(&session->eh_mutex);
2322         spin_lock_bh(&session->lock);
2323         if (conn->stop_stage == STOP_CONN_TERM) {
2324                 spin_unlock_bh(&session->lock);
2325                 mutex_unlock(&session->eh_mutex);
2326                 return;
2327         }
2328
2329         /*
2330          * When this is called for the in_login state, we only want to clean
2331          * up the login task and connection. We do not need to block and set
2332          * the recovery state again
2333          */
2334         if (flag == STOP_CONN_TERM)
2335                 session->state = ISCSI_STATE_TERMINATE;
2336         else if (conn->stop_stage != STOP_CONN_RECOVER)
2337                 session->state = ISCSI_STATE_IN_RECOVERY;
2338
2339         old_stop_stage = conn->stop_stage;
2340         conn->stop_stage = flag;
2341         conn->c_stage = ISCSI_CONN_STOPPED;
2342         spin_unlock_bh(&session->lock);
2343
2344         iscsi_suspend_tx(conn);
2345         /*
2346          * for connection level recovery we should not calculate
2347          * header digest. conn->hdr_size used for optimization
2348          * in hdr_extract() and will be re-negotiated at
2349          * set_param() time.
2350          */
2351         if (flag == STOP_CONN_RECOVER) {
2352                 conn->hdrdgst_en = 0;
2353                 conn->datadgst_en = 0;
2354                 if (session->state == ISCSI_STATE_IN_RECOVERY &&
2355                     old_stop_stage != STOP_CONN_RECOVER) {
2356                         debug_scsi("blocking session\n");
2357                         iscsi_block_session(session->cls_session);
2358                 }
2359         }
2360
2361         /*
2362          * flush queues.
2363          */
2364         spin_lock_bh(&session->lock);
2365         if (STOP_CONN_RECOVER)
2366                 fail_all_commands(conn, -1, DID_TRANSPORT_DISRUPTED);
2367         else
2368                 fail_all_commands(conn, -1, DID_ERROR);
2369         flush_control_queues(session, conn);
2370         spin_unlock_bh(&session->lock);
2371         mutex_unlock(&session->eh_mutex);
2372 }
2373
2374 void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
2375 {
2376         struct iscsi_conn *conn = cls_conn->dd_data;
2377         struct iscsi_session *session = conn->session;
2378
2379         switch (flag) {
2380         case STOP_CONN_RECOVER:
2381         case STOP_CONN_TERM:
2382                 iscsi_start_session_recovery(session, conn, flag);
2383                 break;
2384         default:
2385                 iscsi_conn_printk(KERN_ERR, conn,
2386                                   "invalid stop flag %d\n", flag);
2387         }
2388 }
2389 EXPORT_SYMBOL_GPL(iscsi_conn_stop);
2390
2391 int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
2392                     struct iscsi_cls_conn *cls_conn, int is_leading)
2393 {
2394         struct iscsi_session *session = cls_session->dd_data;
2395         struct iscsi_conn *conn = cls_conn->dd_data;
2396
2397         spin_lock_bh(&session->lock);
2398         if (is_leading)
2399                 session->leadconn = conn;
2400         spin_unlock_bh(&session->lock);
2401
2402         /*
2403          * Unblock xmitworker(), Login Phase will pass through.
2404          */
2405         clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
2406         clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
2407         return 0;
2408 }
2409 EXPORT_SYMBOL_GPL(iscsi_conn_bind);
2410
2411
2412 int iscsi_set_param(struct iscsi_cls_conn *cls_conn,
2413                     enum iscsi_param param, char *buf, int buflen)
2414 {
2415         struct iscsi_conn *conn = cls_conn->dd_data;
2416         struct iscsi_session *session = conn->session;
2417         uint32_t value;
2418
2419         switch(param) {
2420         case ISCSI_PARAM_FAST_ABORT:
2421                 sscanf(buf, "%d", &session->fast_abort);
2422                 break;
2423         case ISCSI_PARAM_ABORT_TMO:
2424                 sscanf(buf, "%d", &session->abort_timeout);
2425                 break;
2426         case ISCSI_PARAM_LU_RESET_TMO:
2427                 sscanf(buf, "%d", &session->lu_reset_timeout);
2428                 break;
2429         case ISCSI_PARAM_PING_TMO:
2430                 sscanf(buf, "%d", &conn->ping_timeout);
2431                 break;
2432         case ISCSI_PARAM_RECV_TMO:
2433                 sscanf(buf, "%d", &conn->recv_timeout);
2434                 break;
2435         case ISCSI_PARAM_MAX_RECV_DLENGTH:
2436                 sscanf(buf, "%d", &conn->max_recv_dlength);
2437                 break;
2438         case ISCSI_PARAM_MAX_XMIT_DLENGTH:
2439                 sscanf(buf, "%d", &conn->max_xmit_dlength);
2440                 break;
2441         case ISCSI_PARAM_HDRDGST_EN:
2442                 sscanf(buf, "%d", &conn->hdrdgst_en);
2443                 break;
2444         case ISCSI_PARAM_DATADGST_EN:
2445                 sscanf(buf, "%d", &conn->datadgst_en);
2446                 break;
2447         case ISCSI_PARAM_INITIAL_R2T_EN:
2448                 sscanf(buf, "%d", &session->initial_r2t_en);
2449                 break;
2450         case ISCSI_PARAM_MAX_R2T:
2451                 sscanf(buf, "%d", &session->max_r2t);
2452                 break;
2453         case ISCSI_PARAM_IMM_DATA_EN:
2454                 sscanf(buf, "%d", &session->imm_data_en);
2455                 break;
2456         case ISCSI_PARAM_FIRST_BURST:
2457                 sscanf(buf, "%d", &session->first_burst);
2458                 break;
2459         case ISCSI_PARAM_MAX_BURST:
2460                 sscanf(buf, "%d", &session->max_burst);
2461                 break;
2462         case ISCSI_PARAM_PDU_INORDER_EN:
2463                 sscanf(buf, "%d", &session->pdu_inorder_en);
2464                 break;
2465         case ISCSI_PARAM_DATASEQ_INORDER_EN:
2466                 sscanf(buf, "%d", &session->dataseq_inorder_en);
2467                 break;
2468         case ISCSI_PARAM_ERL:
2469                 sscanf(buf, "%d", &session->erl);
2470                 break;
2471         case ISCSI_PARAM_IFMARKER_EN:
2472                 sscanf(buf, "%d", &value);
2473                 BUG_ON(value);
2474                 break;
2475         case ISCSI_PARAM_OFMARKER_EN:
2476                 sscanf(buf, "%d", &value);
2477                 BUG_ON(value);
2478                 break;
2479         case ISCSI_PARAM_EXP_STATSN:
2480                 sscanf(buf, "%u", &conn->exp_statsn);
2481                 break;
2482         case ISCSI_PARAM_USERNAME:
2483                 kfree(session->username);
2484                 session->username = kstrdup(buf, GFP_KERNEL);
2485                 if (!session->username)
2486                         return -ENOMEM;
2487                 break;
2488         case ISCSI_PARAM_USERNAME_IN:
2489                 kfree(session->username_in);
2490                 session->username_in = kstrdup(buf, GFP_KERNEL);
2491                 if (!session->username_in)
2492                         return -ENOMEM;
2493                 break;
2494         case ISCSI_PARAM_PASSWORD:
2495                 kfree(session->password);
2496                 session->password = kstrdup(buf, GFP_KERNEL);
2497                 if (!session->password)
2498                         return -ENOMEM;
2499                 break;
2500         case ISCSI_PARAM_PASSWORD_IN:
2501                 kfree(session->password_in);
2502                 session->password_in = kstrdup(buf, GFP_KERNEL);
2503                 if (!session->password_in)
2504                         return -ENOMEM;
2505                 break;
2506         case ISCSI_PARAM_TARGET_NAME:
2507                 /* this should not change between logins */
2508                 if (session->targetname)
2509                         break;
2510
2511                 session->targetname = kstrdup(buf, GFP_KERNEL);
2512                 if (!session->targetname)
2513                         return -ENOMEM;
2514                 break;
2515         case ISCSI_PARAM_TPGT:
2516                 sscanf(buf, "%d", &session->tpgt);
2517                 break;
2518         case ISCSI_PARAM_PERSISTENT_PORT:
2519                 sscanf(buf, "%d", &conn->persistent_port);
2520                 break;
2521         case ISCSI_PARAM_PERSISTENT_ADDRESS:
2522                 /*
2523                  * this is the address returned in discovery so it should
2524                  * not change between logins.
2525                  */
2526                 if (conn->persistent_address)
2527                         break;
2528
2529                 conn->persistent_address = kstrdup(buf, GFP_KERNEL);
2530                 if (!conn->persistent_address)
2531                         return -ENOMEM;
2532                 break;
2533         case ISCSI_PARAM_IFACE_NAME:
2534                 if (!session->ifacename)
2535                         session->ifacename = kstrdup(buf, GFP_KERNEL);
2536                 break;
2537         case ISCSI_PARAM_INITIATOR_NAME:
2538                 if (!session->initiatorname)
2539                         session->initiatorname = kstrdup(buf, GFP_KERNEL);
2540                 break;
2541         default:
2542                 return -ENOSYS;
2543         }
2544
2545         return 0;
2546 }
2547 EXPORT_SYMBOL_GPL(iscsi_set_param);
2548
2549 int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
2550                             enum iscsi_param param, char *buf)
2551 {
2552         struct iscsi_session *session = cls_session->dd_data;
2553         int len;
2554
2555         switch(param) {
2556         case ISCSI_PARAM_FAST_ABORT:
2557                 len = sprintf(buf, "%d\n", session->fast_abort);
2558                 break;
2559         case ISCSI_PARAM_ABORT_TMO:
2560                 len = sprintf(buf, "%d\n", session->abort_timeout);
2561                 break;
2562         case ISCSI_PARAM_LU_RESET_TMO:
2563                 len = sprintf(buf, "%d\n", session->lu_reset_timeout);
2564                 break;
2565         case ISCSI_PARAM_INITIAL_R2T_EN:
2566                 len = sprintf(buf, "%d\n", session->initial_r2t_en);
2567                 break;
2568         case ISCSI_PARAM_MAX_R2T:
2569                 len = sprintf(buf, "%hu\n", session->max_r2t);
2570                 break;
2571         case ISCSI_PARAM_IMM_DATA_EN:
2572                 len = sprintf(buf, "%d\n", session->imm_data_en);
2573                 break;
2574         case ISCSI_PARAM_FIRST_BURST:
2575                 len = sprintf(buf, "%u\n", session->first_burst);
2576                 break;
2577         case ISCSI_PARAM_MAX_BURST:
2578                 len = sprintf(buf, "%u\n", session->max_burst);
2579                 break;
2580         case ISCSI_PARAM_PDU_INORDER_EN:
2581                 len = sprintf(buf, "%d\n", session->pdu_inorder_en);
2582                 break;
2583         case ISCSI_PARAM_DATASEQ_INORDER_EN:
2584                 len = sprintf(buf, "%d\n", session->dataseq_inorder_en);
2585                 break;
2586         case ISCSI_PARAM_ERL:
2587                 len = sprintf(buf, "%d\n", session->erl);
2588                 break;
2589         case ISCSI_PARAM_TARGET_NAME:
2590                 len = sprintf(buf, "%s\n", session->targetname);
2591                 break;
2592         case ISCSI_PARAM_TPGT:
2593                 len = sprintf(buf, "%d\n", session->tpgt);
2594                 break;
2595         case ISCSI_PARAM_USERNAME:
2596                 len = sprintf(buf, "%s\n", session->username);
2597                 break;
2598         case ISCSI_PARAM_USERNAME_IN:
2599                 len = sprintf(buf, "%s\n", session->username_in);
2600                 break;
2601         case ISCSI_PARAM_PASSWORD:
2602                 len = sprintf(buf, "%s\n", session->password);
2603                 break;
2604         case ISCSI_PARAM_PASSWORD_IN:
2605                 len = sprintf(buf, "%s\n", session->password_in);
2606                 break;
2607         case ISCSI_PARAM_IFACE_NAME:
2608                 len = sprintf(buf, "%s\n", session->ifacename);
2609                 break;
2610         case ISCSI_PARAM_INITIATOR_NAME:
2611                 if (!session->initiatorname)
2612                         len = sprintf(buf, "%s\n", "unknown");
2613                 else
2614                         len = sprintf(buf, "%s\n", session->initiatorname);
2615                 break;
2616         default:
2617                 return -ENOSYS;
2618         }
2619
2620         return len;
2621 }
2622 EXPORT_SYMBOL_GPL(iscsi_session_get_param);
2623
2624 int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
2625                          enum iscsi_param param, char *buf)
2626 {
2627         struct iscsi_conn *conn = cls_conn->dd_data;
2628         int len;
2629
2630         switch(param) {
2631         case ISCSI_PARAM_PING_TMO:
2632                 len = sprintf(buf, "%u\n", conn->ping_timeout);
2633                 break;
2634         case ISCSI_PARAM_RECV_TMO:
2635                 len = sprintf(buf, "%u\n", conn->recv_timeout);
2636                 break;
2637         case ISCSI_PARAM_MAX_RECV_DLENGTH:
2638                 len = sprintf(buf, "%u\n", conn->max_recv_dlength);
2639                 break;
2640         case ISCSI_PARAM_MAX_XMIT_DLENGTH:
2641                 len = sprintf(buf, "%u\n", conn->max_xmit_dlength);
2642                 break;
2643         case ISCSI_PARAM_HDRDGST_EN:
2644                 len = sprintf(buf, "%d\n", conn->hdrdgst_en);
2645                 break;
2646         case ISCSI_PARAM_DATADGST_EN:
2647                 len = sprintf(buf, "%d\n", conn->datadgst_en);
2648                 break;
2649         case ISCSI_PARAM_IFMARKER_EN:
2650                 len = sprintf(buf, "%d\n", conn->ifmarker_en);
2651                 break;
2652         case ISCSI_PARAM_OFMARKER_EN:
2653                 len = sprintf(buf, "%d\n", conn->ofmarker_en);
2654                 break;
2655         case ISCSI_PARAM_EXP_STATSN:
2656                 len = sprintf(buf, "%u\n", conn->exp_statsn);
2657                 break;
2658         case ISCSI_PARAM_PERSISTENT_PORT:
2659                 len = sprintf(buf, "%d\n", conn->persistent_port);
2660                 break;
2661         case ISCSI_PARAM_PERSISTENT_ADDRESS:
2662                 len = sprintf(buf, "%s\n", conn->persistent_address);
2663                 break;
2664         default:
2665                 return -ENOSYS;
2666         }
2667
2668         return len;
2669 }
2670 EXPORT_SYMBOL_GPL(iscsi_conn_get_param);
2671
2672 int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
2673                          char *buf)
2674 {
2675         struct iscsi_host *ihost = shost_priv(shost);
2676         int len;
2677
2678         switch (param) {
2679         case ISCSI_HOST_PARAM_NETDEV_NAME:
2680                 if (!ihost->netdev)
2681                         len = sprintf(buf, "%s\n", "default");
2682                 else
2683                         len = sprintf(buf, "%s\n", ihost->netdev);
2684                 break;
2685         case ISCSI_HOST_PARAM_HWADDRESS:
2686                 if (!ihost->hwaddress)
2687                         len = sprintf(buf, "%s\n", "default");
2688                 else
2689                         len = sprintf(buf, "%s\n", ihost->hwaddress);
2690                 break;
2691         case ISCSI_HOST_PARAM_INITIATOR_NAME:
2692                 if (!ihost->initiatorname)
2693                         len = sprintf(buf, "%s\n", "unknown");
2694                 else
2695                         len = sprintf(buf, "%s\n", ihost->initiatorname);
2696                 break;
2697         case ISCSI_HOST_PARAM_IPADDRESS:
2698                 if (!strlen(ihost->local_address))
2699                         len = sprintf(buf, "%s\n", "unknown");
2700                 else
2701                         len = sprintf(buf, "%s\n",
2702                                       ihost->local_address);
2703                 break;
2704         default:
2705                 return -ENOSYS;
2706         }
2707
2708         return len;
2709 }
2710 EXPORT_SYMBOL_GPL(iscsi_host_get_param);
2711
2712 int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param,
2713                          char *buf, int buflen)
2714 {
2715         struct iscsi_host *ihost = shost_priv(shost);
2716
2717         switch (param) {
2718         case ISCSI_HOST_PARAM_NETDEV_NAME:
2719                 if (!ihost->netdev)
2720                         ihost->netdev = kstrdup(buf, GFP_KERNEL);
2721                 break;
2722         case ISCSI_HOST_PARAM_HWADDRESS:
2723                 if (!ihost->hwaddress)
2724                         ihost->hwaddress = kstrdup(buf, GFP_KERNEL);
2725                 break;
2726         case ISCSI_HOST_PARAM_INITIATOR_NAME:
2727                 if (!ihost->initiatorname)
2728                         ihost->initiatorname = kstrdup(buf, GFP_KERNEL);
2729                 break;
2730         default:
2731                 return -ENOSYS;
2732         }
2733
2734         return 0;
2735 }
2736 EXPORT_SYMBOL_GPL(iscsi_host_set_param);
2737
2738 MODULE_AUTHOR("Mike Christie");
2739 MODULE_DESCRIPTION("iSCSI library functions");
2740 MODULE_LICENSE("GPL");