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