2
* Copyright (C) 2002-2003 Ardis Technolgies <roman@ardistech.com>
3
* Copyright (C) 2008 Arne Redlich <agr@powerkom-dd.de>
5
* Released under the terms of the GNU GPL v2.0.
8
#include <linux/module.h>
9
#include <linux/hash.h>
11
#include <scsi/scsi.h>
14
#include "iscsi_dbg.h"
17
unsigned long debug_enable_flags;
18
unsigned long worker_thread_pool_size;
20
static struct kmem_cache *iscsi_cmnd_cache;
21
static u8 dummy_data[PAGE_SIZE];
24
static char ctr_name[] = "ietctl";
25
extern struct file_operations ctr_fops;
27
static u32 cmnd_write_size(struct iscsi_cmnd *cmnd)
29
struct iscsi_scsi_cmd_hdr *hdr = cmnd_hdr(cmnd);
31
if (hdr->flags & ISCSI_CMD_WRITE)
32
return be32_to_cpu(hdr->data_length);
36
static u32 cmnd_read_size(struct iscsi_cmnd *cmnd)
38
struct iscsi_scsi_cmd_hdr *hdr = cmnd_hdr(cmnd);
40
if (hdr->flags & ISCSI_CMD_READ) {
41
struct iscsi_rlength_ahdr *ahdr =
42
(struct iscsi_rlength_ahdr *)cmnd->pdu.ahs;
44
if (!(hdr->flags & ISCSI_CMD_WRITE))
45
return be32_to_cpu(hdr->data_length);
46
if (ahdr && ahdr->ahstype == ISCSI_AHSTYPE_RLENGTH)
47
return be32_to_cpu(ahdr->read_length);
52
static void iscsi_device_queue_cmnd(struct iscsi_cmnd *cmnd)
54
set_cmnd_waitio(cmnd);
58
static void iscsi_scsi_queuecmnd(struct iscsi_cmnd *cmnd)
60
struct iscsi_queue *queue = &cmnd->lun->queue;
62
dprintk(D_GENERIC, "%p\n", cmnd);
64
if ((cmnd->pdu.bhs.flags & ISCSI_CMD_ATTR_MASK) != ISCSI_CMD_UNTAGGED &&
65
(cmnd->pdu.bhs.flags & ISCSI_CMD_ATTR_MASK) != ISCSI_CMD_SIMPLE) {
66
cmnd->pdu.bhs.flags &= ~ISCSI_CMD_ATTR_MASK;
67
cmnd->pdu.bhs.flags |= ISCSI_CMD_UNTAGGED;
70
spin_lock(&queue->queue_lock);
72
set_cmnd_queued(cmnd);
74
switch (cmnd->pdu.bhs.flags & ISCSI_CMD_ATTR_MASK) {
75
case ISCSI_CMD_UNTAGGED:
76
case ISCSI_CMD_SIMPLE:
77
if (!list_empty(&queue->wait_list) || queue->ordered_cmnd)
85
spin_unlock(&queue->queue_lock);
87
iscsi_device_queue_cmnd(cmnd);
90
assert(list_empty(&cmnd->list));
92
list_add_tail(&cmnd->list, &queue->wait_list);
93
spin_unlock(&queue->queue_lock);
97
static void iscsi_scsi_dequeuecmnd(struct iscsi_cmnd *cmnd)
99
struct iscsi_queue *queue;
103
queue = &cmnd->lun->queue;
104
spin_lock(&queue->queue_lock);
105
switch (cmnd->pdu.bhs.flags & ISCSI_CMD_ATTR_MASK) {
106
case ISCSI_CMD_UNTAGGED:
107
case ISCSI_CMD_SIMPLE:
110
case ISCSI_CMD_ORDERED:
111
case ISCSI_CMD_HEAD_OF_QUEUE:
115
/* Should the iscsi_scsi_queuecmnd func reject this ? */
119
while (!list_empty(&queue->wait_list)) {
120
cmnd = list_entry(queue->wait_list.next, struct iscsi_cmnd, list);
121
switch ((cmnd->pdu.bhs.flags & ISCSI_CMD_ATTR_MASK)) {
122
case ISCSI_CMD_UNTAGGED:
123
case ISCSI_CMD_SIMPLE:
124
list_del_init(&cmnd->list);
126
iscsi_device_queue_cmnd(cmnd);
128
case ISCSI_CMD_ORDERED:
129
case ISCSI_CMD_HEAD_OF_QUEUE:
135
spin_unlock(&queue->queue_lock);
141
* create a new command.
143
* iscsi_cmnd_create -
144
* @conn: ptr to connection (for i/o)
146
* @return ptr to command or NULL
149
struct iscsi_cmnd *cmnd_alloc(struct iscsi_conn *conn, int req)
151
struct iscsi_cmnd *cmnd;
153
/* TODO: async interface is necessary ? */
154
cmnd = kmem_cache_alloc(iscsi_cmnd_cache, GFP_KERNEL|__GFP_NOFAIL);
156
memset(cmnd, 0, sizeof(*cmnd));
157
INIT_LIST_HEAD(&cmnd->list);
158
INIT_LIST_HEAD(&cmnd->pdu_list);
159
INIT_LIST_HEAD(&cmnd->conn_list);
160
INIT_LIST_HEAD(&cmnd->hash_list);
162
spin_lock(&conn->list_lock);
163
atomic_inc(&conn->nr_cmnds);
165
list_add_tail(&cmnd->conn_list, &conn->pdu_list);
166
spin_unlock(&conn->list_lock);
169
dprintk(D_GENERIC, "%p:%p\n", conn, cmnd);
175
* create a new command used as response.
177
* iscsi_cmnd_create_rsp_cmnd -
178
* @cmnd: ptr to request command
180
* @return ptr to response command or NULL
183
static struct iscsi_cmnd *iscsi_cmnd_create_rsp_cmnd(struct iscsi_cmnd *cmnd, int final)
185
struct iscsi_cmnd *rsp = cmnd_alloc(cmnd->conn, 0);
189
list_add_tail(&rsp->pdu_list, &cmnd->pdu_list);
194
static struct iscsi_cmnd *get_rsp_cmnd(struct iscsi_cmnd *req)
196
return list_entry(req->pdu_list.prev, struct iscsi_cmnd, pdu_list);
199
static void iscsi_cmnds_init_write(struct list_head *send)
201
struct iscsi_cmnd *cmnd = list_entry(send->next, struct iscsi_cmnd, list);
202
struct iscsi_conn *conn = cmnd->conn;
203
struct list_head *pos, *next;
205
spin_lock(&conn->list_lock);
207
list_for_each_safe(pos, next, send) {
208
cmnd = list_entry(pos, struct iscsi_cmnd, list);
210
dprintk(D_GENERIC, "%p:%x\n", cmnd, cmnd_opcode(cmnd));
212
list_del_init(&cmnd->list);
213
assert(conn == cmnd->conn);
214
list_add_tail(&cmnd->list, &conn->write_list);
217
spin_unlock(&conn->list_lock);
219
nthread_wakeup(conn->session->target);
222
static void iscsi_cmnd_init_write(struct iscsi_cmnd *cmnd)
226
if (!list_empty(&cmnd->list)) {
227
eprintk("%x %x %x %x %lx %u %u %u %u %u %u %u %d %d\n",
228
cmnd_itt(cmnd), cmnd_ttt(cmnd), cmnd_opcode(cmnd),
229
cmnd_scsicode(cmnd), cmnd->flags, cmnd->r2t_sn,
230
cmnd->r2t_length, cmnd->is_unsolicited_data,
231
cmnd->target_task_tag, cmnd->outstanding_r2t,
232
cmnd->hdigest, cmnd->ddigest,
233
list_empty(&cmnd->pdu_list), list_empty(&cmnd->hash_list));
235
assert(list_empty(&cmnd->list));
237
list_add(&cmnd->list, &head);
238
iscsi_cmnds_init_write(&head);
241
static void do_send_data_rsp(struct iscsi_cmnd *cmnd)
243
struct iscsi_conn *conn = cmnd->conn;
244
struct iscsi_cmnd *data_cmnd;
245
struct tio *tio = cmnd->tio;
246
struct iscsi_scsi_cmd_hdr *req = cmnd_hdr(cmnd);
247
struct iscsi_data_in_hdr *rsp;
248
u32 pdusize, expsize, scsisize, size, offset, sn;
251
dprintk(D_GENERIC, "%p\n", cmnd);
252
pdusize = conn->session->param.max_xmit_data_length;
253
expsize = cmnd_read_size(cmnd);
254
size = min(expsize, tio->size);
259
data_cmnd = iscsi_cmnd_create_rsp_cmnd(cmnd, size <= pdusize);
261
data_cmnd->tio = tio;
262
rsp = (struct iscsi_data_in_hdr *)&data_cmnd->pdu.bhs;
264
rsp->opcode = ISCSI_OP_SCSI_DATA_IN;
266
rsp->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
267
rsp->buffer_offset = offset;
268
rsp->data_sn = cpu_to_be32(sn);
270
if (size <= pdusize) {
271
data_cmnd->pdu.datasize = size;
272
rsp->flags = ISCSI_FLG_FINAL | ISCSI_FLG_STATUS;
274
scsisize = tio->size;
275
if (scsisize < expsize) {
276
rsp->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW;
277
size = expsize - scsisize;
278
} else if (scsisize > expsize) {
279
rsp->flags |= ISCSI_FLG_RESIDUAL_OVERFLOW;
280
size = scsisize - expsize;
283
rsp->residual_count = cpu_to_be32(size);
284
list_add_tail(&data_cmnd->list, &send);
289
data_cmnd->pdu.datasize = pdusize;
295
list_add_tail(&data_cmnd->list, &send);
298
iscsi_cmnds_init_write(&send);
301
static struct iscsi_cmnd *create_scsi_rsp(struct iscsi_cmnd *req)
303
struct iscsi_cmnd *rsp;
304
struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req);
305
struct iscsi_scsi_rsp_hdr *rsp_hdr;
306
struct iscsi_sense_data *sense;
308
rsp = iscsi_cmnd_create_rsp_cmnd(req, 1);
310
rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs;
311
rsp_hdr->opcode = ISCSI_OP_SCSI_RSP;
312
rsp_hdr->flags = ISCSI_FLG_FINAL;
313
rsp_hdr->response = ISCSI_RESPONSE_COMMAND_COMPLETED;
314
rsp_hdr->cmd_status = req->status;
315
rsp_hdr->itt = req_hdr->itt;
317
if (req->status == SAM_STAT_CHECK_CONDITION) {
319
rsp->tio = tio_alloc(1);
320
sense = (struct iscsi_sense_data *)
321
page_address(rsp->tio->pvec[0]);
325
sense->length = cpu_to_be16(IET_SENSE_BUF_SIZE);
327
memcpy(sense->data, req->sense_buf, IET_SENSE_BUF_SIZE);
328
rsp->pdu.datasize = sizeof(struct iscsi_sense_data) +
331
rsp->tio->size = (rsp->pdu.datasize + 3) & -4;
332
rsp->tio->offset = 0;
338
void iscsi_cmnd_set_sense(struct iscsi_cmnd *cmnd, u8 sense_key, u8 asc,
341
cmnd->status = SAM_STAT_CHECK_CONDITION;
343
cmnd->sense_buf[0] = 0xf0;
344
cmnd->sense_buf[2] = sense_key;
345
cmnd->sense_buf[7] = 6; // Additional sense length
346
cmnd->sense_buf[12] = asc;
347
cmnd->sense_buf[13] = ascq;
349
/* Call to ACA/UAI handler */
352
static struct iscsi_cmnd *create_sense_rsp(struct iscsi_cmnd *req,
353
u8 sense_key, u8 asc, u8 ascq)
355
iscsi_cmnd_set_sense(req, sense_key, asc, ascq);
356
return create_scsi_rsp(req);
359
void send_scsi_rsp(struct iscsi_cmnd *req, void (*func)(struct iscsi_cmnd *))
361
struct iscsi_cmnd *rsp;
362
struct iscsi_scsi_rsp_hdr *rsp_hdr;
366
rsp = create_scsi_rsp(req);
368
switch (req->status) {
370
case SAM_STAT_RESERVATION_CONFLICT:
371
rsp_hdr = (struct iscsi_scsi_rsp_hdr *) &rsp->pdu.bhs;
372
if ((size = cmnd_read_size(req)) != 0) {
373
rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW;
374
rsp_hdr->residual_count = cpu_to_be32(size);
381
iscsi_cmnd_init_write(rsp);
384
void send_data_rsp(struct iscsi_cmnd *req, void (*func)(struct iscsi_cmnd *))
386
struct iscsi_cmnd *rsp;
390
if (req->status == SAM_STAT_GOOD)
391
do_send_data_rsp(req);
393
rsp = create_scsi_rsp(req);
394
iscsi_cmnd_init_write(rsp);
400
* Also frees the additional header.
402
* iscsi_cmnd_remove -
403
* @cmnd: ptr to command
406
static void iscsi_cmnd_remove(struct iscsi_cmnd *cmnd)
408
struct iscsi_conn *conn;
413
if (cmnd_timer_active(cmnd)) {
414
clear_cmnd_timer_active(cmnd);
415
del_timer_sync(&cmnd->timer);
418
dprintk(D_GENERIC, "%p\n", cmnd);
420
kfree(cmnd->pdu.ahs);
422
if (!list_empty(&cmnd->list)) {
423
struct iscsi_scsi_cmd_hdr *req = cmnd_hdr(cmnd);
425
eprintk("cmnd %p still on some list?, %x, %x, %x, %x, %x, %x, %x %lx\n",
426
cmnd, req->opcode, req->scb[0], req->flags, req->itt,
427
be32_to_cpu(req->data_length),
428
req->cmd_sn, be32_to_cpu(cmnd->pdu.datasize),
432
struct iscsi_scsi_cmd_hdr *req = cmnd_hdr(cmnd->req);
433
eprintk("%p %x %u\n", req, req->opcode, req->scb[0]);
438
list_del(&cmnd->list);
439
spin_lock(&conn->list_lock);
440
atomic_dec(&conn->nr_cmnds);
441
list_del(&cmnd->conn_list);
442
spin_unlock(&conn->list_lock);
447
kmem_cache_free(iscsi_cmnd_cache, cmnd);
450
static void cmnd_skip_pdu(struct iscsi_cmnd *cmnd)
452
struct iscsi_conn *conn = cmnd->conn;
453
struct tio *tio = cmnd->tio;
458
eprintk("%x %x %x %u\n", cmnd_itt(cmnd), cmnd_opcode(cmnd),
459
cmnd_hdr(cmnd)->scb[0], cmnd->pdu.datasize);
461
if (!(size = cmnd->pdu.datasize))
465
assert(tio->pg_cnt > 0);
467
tio = cmnd->tio = tio_alloc(1);
469
addr = page_address(tio->pvec[0]);
471
size = (size + 3) & -4;
472
conn->read_size = size;
473
for (i = 0; size > PAGE_CACHE_SIZE; i++, size -= PAGE_CACHE_SIZE) {
474
assert(i < ISCSI_CONN_IOV_MAX);
475
conn->read_iov[i].iov_base = addr;
476
conn->read_iov[i].iov_len = PAGE_CACHE_SIZE;
478
conn->read_iov[i].iov_base = addr;
479
conn->read_iov[i].iov_len = size;
480
conn->read_msg.msg_iov = conn->read_iov;
481
conn->read_msg.msg_iovlen = ++i;
484
static void iscsi_cmnd_reject(struct iscsi_cmnd *req, int reason)
486
struct iscsi_cmnd *rsp;
487
struct iscsi_reject_hdr *rsp_hdr;
491
rsp = iscsi_cmnd_create_rsp_cmnd(req, 1);
492
rsp_hdr = (struct iscsi_reject_hdr *)&rsp->pdu.bhs;
494
rsp_hdr->opcode = ISCSI_OP_REJECT;
495
rsp_hdr->ffffffff = ISCSI_RESERVED_TAG;
496
rsp_hdr->reason = reason;
498
rsp->tio = tio = tio_alloc(1);
499
addr = page_address(tio->pvec[0]);
501
memcpy(addr, &req->pdu.bhs, sizeof(struct iscsi_hdr));
502
tio->size = rsp->pdu.datasize = sizeof(struct iscsi_hdr);
505
req->pdu.bhs.opcode = ISCSI_OP_PDU_REJECT;
508
static void cmnd_set_sn(struct iscsi_cmnd *cmnd, int set_stat_sn)
510
struct iscsi_conn *conn = cmnd->conn;
511
struct iscsi_session *sess = conn->session;
514
cmnd->pdu.bhs.sn = cpu_to_be32(conn->stat_sn++);
515
cmnd->pdu.bhs.exp_sn = cpu_to_be32(sess->exp_cmd_sn);
516
cmnd->pdu.bhs.max_sn = cpu_to_be32(sess->exp_cmd_sn + sess->max_queued_cmnds);
519
static void update_stat_sn(struct iscsi_cmnd *cmnd)
521
struct iscsi_conn *conn = cmnd->conn;
524
cmnd->pdu.bhs.exp_sn = exp_stat_sn = be32_to_cpu(cmnd->pdu.bhs.exp_sn);
525
dprintk(D_GENERIC, "%x,%x\n", cmnd_opcode(cmnd), exp_stat_sn);
526
if ((int)(exp_stat_sn - conn->exp_stat_sn) > 0 &&
527
(int)(exp_stat_sn - conn->stat_sn) <= 0) {
528
// free pdu resources
529
cmnd->conn->exp_stat_sn = exp_stat_sn;
533
static int check_cmd_sn(struct iscsi_cmnd *cmnd)
535
struct iscsi_session *session = cmnd->conn->session;
538
cmnd->pdu.bhs.sn = cmd_sn = be32_to_cpu(cmnd->pdu.bhs.sn);
540
dprintk(D_GENERIC, "cmd_sn(%u) exp_cmd_sn(%u) max_cmd_sn(%u)\n",
541
cmd_sn, session->exp_cmd_sn, session->max_cmd_sn);
543
if (between(cmd_sn, session->exp_cmd_sn, session->max_cmd_sn))
545
else if (cmnd_immediate(cmnd))
548
eprintk("sequence error: cmd_sn(%u) exp_cmd_sn(%u) max_cmd_sn(%u)\n",
549
cmd_sn, session->exp_cmd_sn, session->max_cmd_sn);
551
set_cmnd_tmfabort(cmnd);
553
return -ISCSI_REASON_PROTOCOL_ERROR;
556
static struct iscsi_cmnd *__cmnd_find_hash(struct iscsi_session *session, u32 itt, u32 ttt)
558
struct list_head *head;
559
struct iscsi_cmnd *cmnd;
561
head = &session->cmnd_hash[cmnd_hashfn(itt)];
563
list_for_each_entry(cmnd, head, hash_list) {
564
if (cmnd->pdu.bhs.itt == itt) {
565
if ((ttt != ISCSI_RESERVED_TAG) && (ttt != cmnd->target_task_tag))
574
static struct iscsi_cmnd *cmnd_find_hash(struct iscsi_session *session, u32 itt, u32 ttt)
576
struct iscsi_cmnd *cmnd;
578
spin_lock(&session->cmnd_hash_lock);
580
cmnd = __cmnd_find_hash(session, itt, ttt);
582
spin_unlock(&session->cmnd_hash_lock);
587
static int cmnd_insert_hash_ttt(struct iscsi_cmnd *cmnd, u32 ttt)
589
struct iscsi_session *session = cmnd->conn->session;
590
struct iscsi_cmnd *tmp;
591
struct list_head *head;
593
u32 itt = cmnd->pdu.bhs.itt;
595
head = &session->cmnd_hash[cmnd_hashfn(itt)];
597
spin_lock(&session->cmnd_hash_lock);
599
tmp = __cmnd_find_hash(session, itt, ttt);
601
list_add_tail(&cmnd->hash_list, head);
602
set_cmnd_hashed(cmnd);
604
err = -ISCSI_REASON_TASK_IN_PROGRESS;
606
spin_unlock(&session->cmnd_hash_lock);
611
static int cmnd_insert_hash(struct iscsi_cmnd *cmnd)
615
dprintk(D_GENERIC, "%p:%x\n", cmnd, cmnd->pdu.bhs.itt);
617
if (cmnd->pdu.bhs.itt == ISCSI_RESERVED_TAG)
618
return -ISCSI_REASON_PROTOCOL_ERROR;
620
err = cmnd_insert_hash_ttt(cmnd, ISCSI_RESERVED_TAG);
622
update_stat_sn(cmnd);
623
err = check_cmd_sn(cmnd);
624
} else if (!cmnd_immediate(cmnd))
625
set_cmnd_tmfabort(cmnd);
630
static void __cmnd_remove_hash(struct iscsi_cmnd *cmnd)
632
list_del(&cmnd->hash_list);
635
static void cmnd_remove_hash(struct iscsi_cmnd *cmnd)
637
struct iscsi_session *session = cmnd->conn->session;
638
struct iscsi_cmnd *tmp;
640
spin_lock(&session->cmnd_hash_lock);
642
tmp = __cmnd_find_hash(session, cmnd->pdu.bhs.itt,
643
cmnd->target_task_tag);
644
if (tmp && tmp == cmnd)
645
__cmnd_remove_hash(tmp);
647
eprintk("%p:%x not found\n", cmnd, cmnd_itt(cmnd));
649
spin_unlock(&session->cmnd_hash_lock);
652
static void cmnd_skip_data(struct iscsi_cmnd *req)
654
struct iscsi_cmnd *rsp;
655
struct iscsi_scsi_rsp_hdr *rsp_hdr;
658
rsp = get_rsp_cmnd(req);
659
rsp_hdr = (struct iscsi_scsi_rsp_hdr *)&rsp->pdu.bhs;
660
if (cmnd_opcode(rsp) != ISCSI_OP_SCSI_RSP) {
661
eprintk("unexpected response command %u\n", cmnd_opcode(rsp));
665
size = cmnd_write_size(req);
667
rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW;
668
rsp_hdr->residual_count = cpu_to_be32(size);
670
size = cmnd_read_size(req);
672
if (cmnd_hdr(req)->flags & ISCSI_CMD_WRITE) {
673
rsp_hdr->flags |= ISCSI_FLG_BIRESIDUAL_UNDERFLOW;
674
rsp_hdr->bi_residual_count = cpu_to_be32(size);
676
rsp_hdr->flags |= ISCSI_FLG_RESIDUAL_UNDERFLOW;
677
rsp_hdr->residual_count = cpu_to_be32(size);
680
req->pdu.bhs.opcode =
681
(req->pdu.bhs.opcode & ~ISCSI_OPCODE_MASK) | ISCSI_OP_SCSI_REJECT;
686
static int cmnd_recv_pdu(struct iscsi_conn *conn, struct tio *tio, u32 offset, u32 size)
691
dprintk(D_GENERIC, "%p %u,%u\n", tio, offset, size);
692
offset += tio->offset;
694
if (!(offset < tio->offset + tio->size) ||
695
!(offset + size <= tio->offset + tio->size)) {
696
eprintk("%u %u %u %u", offset, size, tio->offset, tio->size);
699
assert(offset < tio->offset + tio->size);
700
assert(offset + size <= tio->offset + tio->size);
702
idx = offset >> PAGE_CACHE_SHIFT;
703
offset &= ~PAGE_CACHE_MASK;
705
conn->read_msg.msg_iov = conn->read_iov;
706
conn->read_size = size = (size + 3) & -4;
707
conn->read_overflow = 0;
711
assert(tio->pvec[idx]);
712
addr = page_address(tio->pvec[idx]);
714
conn->read_iov[i].iov_base = addr + offset;
715
if (offset + size <= PAGE_CACHE_SIZE) {
716
conn->read_iov[i].iov_len = size;
717
conn->read_msg.msg_iovlen = ++i;
720
conn->read_iov[i].iov_len = PAGE_CACHE_SIZE - offset;
721
size -= conn->read_iov[i].iov_len;
723
if (++i >= ISCSI_CONN_IOV_MAX) {
724
conn->read_msg.msg_iovlen = i;
725
conn->read_overflow = size;
726
conn->read_size -= size;
736
static void set_offset_and_length(struct iet_volume *lu, u8 *cmd, loff_t *off, u32 *len)
743
*off = ((cmd[1] & 0x1f) << 16) + (cmd[2] << 8) + cmd[3];
751
*off = (u32)cmd[2] << 24 | (u32)cmd[3] << 16 |
752
(u32)cmd[4] << 8 | (u32)cmd[5];
753
*len = (cmd[7] << 8) + cmd[8];
757
*off = (u64)cmd[2] << 56 | (u64)cmd[3] << 48 |
758
(u64)cmd[4] << 40 | (u64)cmd[5] << 32 |
759
(u64)cmd[6] << 24 | (u64)cmd[7] << 16 |
760
(u64)cmd[8] << 8 | (u64)cmd[9];
761
*len = (u32)cmd[10] << 24 | (u32)cmd[11] << 16 |
762
(u32)cmd[12] << 8 | (u32)cmd[13];
768
*off <<= lu->blk_shift;
769
*len <<= lu->blk_shift;
772
static u32 translate_lun(u16 * data)
782
lun = (0x3f & p[0]) << 8 | p[1];
787
eprintk("%u %u %u %u\n", data[0], data[1], data[2], data[3]);
794
static void send_r2t(struct iscsi_cmnd *req)
796
struct iscsi_cmnd *rsp;
797
struct iscsi_r2t_hdr *rsp_hdr;
798
u32 length, offset, burst;
801
length = req->r2t_length;
802
burst = req->conn->session->param.max_burst_length;
803
offset = be32_to_cpu(cmnd_hdr(req)->data_length) - length;
806
rsp = iscsi_cmnd_create_rsp_cmnd(req, 0);
807
rsp->pdu.bhs.ttt = req->target_task_tag;
809
rsp_hdr = (struct iscsi_r2t_hdr *)&rsp->pdu.bhs;
810
rsp_hdr->opcode = ISCSI_OP_R2T;
811
rsp_hdr->flags = ISCSI_FLG_FINAL;
812
memcpy(rsp_hdr->lun, cmnd_hdr(req)->lun, 8);
813
rsp_hdr->itt = cmnd_hdr(req)->itt;
814
rsp_hdr->r2t_sn = cpu_to_be32(req->r2t_sn++);
815
rsp_hdr->buffer_offset = cpu_to_be32(offset);
816
if (length > burst) {
817
rsp_hdr->data_length = cpu_to_be32(burst);
821
rsp_hdr->data_length = cpu_to_be32(length);
825
dprintk(D_WRITE, "%x %u %u %u %u\n", cmnd_itt(req),
826
be32_to_cpu(rsp_hdr->data_length),
827
be32_to_cpu(rsp_hdr->buffer_offset),
828
be32_to_cpu(rsp_hdr->r2t_sn), req->outstanding_r2t);
830
list_add_tail(&rsp->list, &send);
832
if (++req->outstanding_r2t >= req->conn->session->param.max_outstanding_r2t)
837
iscsi_cmnds_init_write(&send);
840
static void scsi_cmnd_exec(struct iscsi_cmnd *cmnd)
842
assert(!cmnd->r2t_length);
845
iscsi_scsi_queuecmnd(cmnd);
847
iscsi_device_queue_cmnd(cmnd);
851
static int nop_out_start(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
856
if (cmnd_ttt(cmnd) != cpu_to_be32(ISCSI_RESERVED_TAG)) {
857
cmnd->req = cmnd_find_hash(conn->session, cmnd->pdu.bhs.itt,
861
* We didn't request this NOP-Out (by sending a
862
* NOP-In, see 10.18.2 of the RFC) or our fake NOP-Out
865
eprintk("initiator bug %x\n", cmnd_itt(cmnd));
866
err = -ISCSI_REASON_PROTOCOL_ERROR;
870
del_timer_sync(&cmnd->req->timer);
871
clear_cmnd_timer_active(cmnd->req);
872
dprintk(D_GENERIC, "NOP-Out: %p, ttt %x, timer %p\n",
873
cmnd->req, cmnd_ttt(cmnd->req), &cmnd->req->timer);
876
if (cmnd_itt(cmnd) == cpu_to_be32(ISCSI_RESERVED_TAG)) {
877
if (!cmnd_immediate(cmnd))
878
eprintk("%s\n", "initiator bug!");
879
update_stat_sn(cmnd);
880
err = check_cmd_sn(cmnd);
883
} else if ((err = cmnd_insert_hash(cmnd)) < 0) {
884
eprintk("ignore this request %x\n", cmnd_itt(cmnd));
888
if ((size = cmnd->pdu.datasize)) {
889
size = (size + 3) & -4;
890
conn->read_msg.msg_iov = conn->read_iov;
891
if (cmnd->pdu.bhs.itt != cpu_to_be32(ISCSI_RESERVED_TAG)) {
893
int pg_cnt = get_pgcnt(size, 0);
895
assert(pg_cnt < ISCSI_CONN_IOV_MAX);
896
cmnd->tio = tio = tio_alloc(pg_cnt);
897
tio_set(tio, size, 0);
899
for (i = 0; i < pg_cnt; i++) {
900
conn->read_iov[i].iov_base
901
= page_address(tio->pvec[i]);
902
tmp = min_t(u32, size, PAGE_CACHE_SIZE);
903
conn->read_iov[i].iov_len = tmp;
904
conn->read_size += tmp;
908
for (i = 0; i < ISCSI_CONN_IOV_MAX; i++) {
909
conn->read_iov[i].iov_base = dummy_data;
910
tmp = min_t(u32, size, sizeof(dummy_data));
911
conn->read_iov[i].iov_len = tmp;
912
conn->read_size += tmp;
917
conn->read_overflow = size;
918
conn->read_msg.msg_iovlen = i;
925
static u32 get_next_ttt(struct iscsi_session *session)
929
if (session->next_ttt == ISCSI_RESERVED_TAG)
931
ttt = session->next_ttt++;
933
return cpu_to_be32(ttt);
936
static void scsi_cmnd_start(struct iscsi_conn *conn, struct iscsi_cmnd *req)
938
struct iscsi_scsi_cmd_hdr *req_hdr = cmnd_hdr(req);
940
dprintk(D_GENERIC, "scsi command: %02x\n", req_hdr->scb[0]);
942
req->lun = volume_get(conn->session->target, translate_lun(req_hdr->lun));
944
switch (req_hdr->scb[0]) {
949
eprintk("%x %x\n", cmnd_itt(req), req_hdr->scb[0]);
950
create_sense_rsp(req, ILLEGAL_REQUEST, 0x25, 0x0);
957
switch (req_hdr->scb[0]) {
958
case SERVICE_ACTION_IN:
959
if ((req_hdr->scb[1] & 0x1f) != 0x10)
963
case TEST_UNIT_READY:
964
case SYNCHRONIZE_CACHE:
974
if (!(req_hdr->flags & ISCSI_CMD_FINAL) || req->pdu.datasize) {
975
/* unexpected unsolicited data */
976
eprintk("%x %x\n", cmnd_itt(req), req_hdr->scb[0]);
977
create_sense_rsp(req, ABORTED_COMMAND, 0xc, 0xc);
989
if (!(req_hdr->flags & ISCSI_CMD_FINAL) || req->pdu.datasize) {
990
/* unexpected unsolicited data */
991
eprintk("%x %x\n", cmnd_itt(req), req_hdr->scb[0]);
992
create_sense_rsp(req, ABORTED_COMMAND, 0xc, 0xc);
997
set_offset_and_length(req->lun, req_hdr->scb, &offset, &length);
998
req->tio = tio_alloc(get_pgcnt(length, offset));
999
tio_set(req->tio, length, offset);
1007
struct iscsi_sess_param *param = &conn->session->param;
1011
req->r2t_length = be32_to_cpu(req_hdr->data_length) - req->pdu.datasize;
1012
req->is_unsolicited_data = !(req_hdr->flags & ISCSI_CMD_FINAL);
1013
req->target_task_tag = get_next_ttt(conn->session);
1015
if (LUReadonly(req->lun)) {
1016
create_sense_rsp(req, DATA_PROTECT, 0x27, 0x0);
1017
cmnd_skip_data(req);
1021
if (!param->immediate_data && req->pdu.datasize)
1022
eprintk("%x %x\n", cmnd_itt(req), req_hdr->scb[0]);
1024
if (param->initial_r2t && !(req_hdr->flags & ISCSI_CMD_FINAL))
1025
eprintk("%x %x\n", cmnd_itt(req), req_hdr->scb[0]);
1027
if (req_hdr->scb[0] == WRITE_VERIFY && req_hdr->scb[1] & 0x02)
1028
eprintk("Verification is ignored %x\n", cmnd_itt(req));
1030
set_offset_and_length(req->lun, req_hdr->scb, &offset, &length);
1031
if (cmnd_write_size(req) != length)
1032
eprintk("%x %u %u\n", cmnd_itt(req), cmnd_write_size(req), length);
1034
req->tio = tio_alloc(get_pgcnt(length, offset));
1035
tio_set(req->tio, length, offset);
1037
if (req->pdu.datasize) {
1038
if (cmnd_recv_pdu(conn, req->tio, 0, req->pdu.datasize) < 0)
1045
eprintk("Unsupported %x\n", req_hdr->scb[0]);
1046
create_sense_rsp(req, ILLEGAL_REQUEST, 0x20, 0x0);
1047
cmnd_skip_data(req);
1055
static void data_out_start(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
1057
struct iscsi_data_out_hdr *req = (struct iscsi_data_out_hdr *)&cmnd->pdu.bhs;
1058
struct iscsi_cmnd *scsi_cmnd = NULL;
1059
u32 offset = be32_to_cpu(req->buffer_offset);
1061
update_stat_sn(cmnd);
1063
cmnd->req = scsi_cmnd = cmnd_find_hash(conn->session, req->itt, req->ttt);
1065
eprintk("unable to find scsi task %x %x\n",
1066
cmnd_itt(cmnd), cmnd_ttt(cmnd));
1070
if (scsi_cmnd->r2t_length < cmnd->pdu.datasize) {
1071
eprintk("invalid data len %x %u %u\n",
1072
cmnd_itt(scsi_cmnd), cmnd->pdu.datasize, scsi_cmnd->r2t_length);
1076
if (scsi_cmnd->r2t_length + offset != cmnd_write_size(scsi_cmnd)) {
1077
eprintk("%x %u %u %u\n", cmnd_itt(scsi_cmnd), scsi_cmnd->r2t_length,
1078
offset, cmnd_write_size(scsi_cmnd));
1082
scsi_cmnd->r2t_length -= cmnd->pdu.datasize;
1084
if (req->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) {
1085
/* unsolicited burst data */
1086
if (scsi_cmnd->pdu.bhs.flags & ISCSI_FLG_FINAL) {
1087
eprintk("unexpected data from %x %x\n",
1088
cmnd_itt(cmnd), cmnd_ttt(cmnd));
1093
dprintk(D_WRITE, "%u %p %p %p %u %u\n", req->ttt, cmnd, scsi_cmnd,
1094
scsi_cmnd->tio, offset, cmnd->pdu.datasize);
1096
if (cmnd_recv_pdu(conn, scsi_cmnd->tio, offset, cmnd->pdu.datasize) < 0)
1101
cmnd->pdu.bhs.opcode = ISCSI_OP_DATA_REJECT;
1102
cmnd_skip_pdu(cmnd);
1106
static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd);
1108
static void data_out_end(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
1110
struct iscsi_data_out_hdr *req = (struct iscsi_data_out_hdr *) &cmnd->pdu.bhs;
1111
struct iscsi_cmnd *scsi_cmnd;
1115
scsi_cmnd = cmnd->req;
1118
if (conn->read_overflow) {
1119
eprintk("%x %u\n", cmnd_itt(cmnd), conn->read_overflow);
1120
assert(scsi_cmnd->tio);
1121
offset = be32_to_cpu(req->buffer_offset);
1122
offset += cmnd->pdu.datasize - conn->read_overflow;
1123
if (cmnd_recv_pdu(conn, scsi_cmnd->tio, offset, conn->read_overflow) < 0)
1128
if (req->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) {
1129
if (req->flags & ISCSI_FLG_FINAL) {
1130
scsi_cmnd->is_unsolicited_data = 0;
1131
iscsi_session_push_cmnd(scsi_cmnd);
1134
/* TODO : proper error handling */
1135
if (!(req->flags & ISCSI_FLG_FINAL) && scsi_cmnd->r2t_length == 0)
1136
eprintk("initiator error %x\n", cmnd_itt(scsi_cmnd));
1138
if (!(req->flags & ISCSI_FLG_FINAL))
1141
scsi_cmnd->outstanding_r2t--;
1143
if (scsi_cmnd->r2t_length == 0)
1144
assert(list_empty(&scsi_cmnd->pdu_list));
1146
iscsi_session_push_cmnd(scsi_cmnd);
1150
iscsi_cmnd_remove(cmnd);
1154
static void __cmnd_abort(struct iscsi_cmnd *cmnd)
1156
if (cmnd_rxstart(cmnd))
1157
set_cmnd_tmfabort(cmnd);
1159
if (cmnd_waitio(cmnd))
1162
if (cmnd->conn->read_cmnd != cmnd)
1163
cmnd_release(cmnd, 1);
1166
static int cmnd_abort(struct iscsi_session *session, struct iscsi_cmnd *req)
1168
struct iscsi_task_mgt_hdr *req_hdr =
1169
(struct iscsi_task_mgt_hdr *)&req->pdu.bhs;
1170
struct iscsi_cmnd *cmnd;
1172
u32 min_cmd_sn = req_hdr->cmd_sn - session->max_queued_cmnds;
1174
req_hdr->ref_cmd_sn = be32_to_cpu(req_hdr->ref_cmd_sn);
1176
dprintk(D_GENERIC, "cmd_sn(%u) ref_cmd_sn(%u) min_cmd_sn(%u) rtt(%x)"
1177
" lun(%d) cid(%u)\n",
1178
req_hdr->cmd_sn, req_hdr->ref_cmd_sn, min_cmd_sn, req_hdr->rtt,
1179
translate_lun(req_hdr->lun), req->conn->cid);
1181
if (after(req_hdr->ref_cmd_sn, req_hdr->cmd_sn))
1182
return ISCSI_RESPONSE_FUNCTION_REJECTED;
1184
if (!(cmnd = cmnd_find_hash(session, req_hdr->rtt, ISCSI_RESERVED_TAG))) {
1185
if (between(req_hdr->ref_cmd_sn, min_cmd_sn, req_hdr->cmd_sn))
1186
return ISCSI_RESPONSE_FUNCTION_COMPLETE;
1188
return ISCSI_RESPONSE_UNKNOWN_TASK;
1191
dprintk(D_GENERIC, "itt(%x) opcode(%x) scsicode(%x) lun(%d) cid(%u)\n",
1192
cmnd_itt(cmnd), cmnd_opcode(cmnd), cmnd_scsicode(cmnd),
1193
translate_lun(cmnd_hdr(cmnd)->lun), cmnd->conn->cid);
1195
if (cmnd_opcode(cmnd) == ISCSI_OP_SCSI_TASK_MGT_MSG)
1196
return ISCSI_RESPONSE_FUNCTION_REJECTED;
1198
if (translate_lun(cmnd_hdr(cmnd)->lun) !=
1199
translate_lun(req_hdr->lun))
1200
return ISCSI_RESPONSE_FUNCTION_REJECTED;
1202
if (cmnd->conn && test_bit(CONN_ACTIVE, &cmnd->conn->state)) {
1203
if (cmnd->conn->cid != req->conn->cid)
1204
return ISCSI_RESPONSE_FUNCTION_REJECTED;
1206
/* Switch cmnd connection allegiance */
1211
return ISCSI_RESPONSE_FUNCTION_COMPLETE;
1214
static int target_reset(struct iscsi_cmnd *req, u32 lun, int all)
1216
struct iscsi_target *target = req->conn->session->target;
1217
struct iscsi_session *session;
1218
struct iscsi_conn *conn;
1219
struct iscsi_cmnd *cmnd, *tmp;
1220
struct iet_volume *volume;
1222
list_for_each_entry(session, &target->session_list, list) {
1223
list_for_each_entry(conn, &session->conn_list, list) {
1224
list_for_each_entry_safe(cmnd, tmp, &conn->pdu_list, conn_list) {
1230
else if (translate_lun(cmnd_hdr(cmnd)->lun)
1237
list_for_each_entry(volume, &target->volumes, list) {
1238
if (all || volume->lun == lun) {
1240
volume_release(volume, 0, 1);
1241
/* power-on, reset, or bus device reset occurred */
1242
ua_establish_for_all_sessions(target, volume->lun,
1250
static void task_set_abort(struct iscsi_cmnd *req)
1252
struct iscsi_session *session = req->conn->session;
1253
struct iscsi_conn *conn;
1254
struct iscsi_cmnd *cmnd, *tmp;
1256
list_for_each_entry(conn, &session->conn_list, list) {
1257
list_for_each_entry_safe(cmnd, tmp, &conn->pdu_list, conn_list) {
1258
if (translate_lun(cmnd_hdr(cmnd)->lun)
1259
!= translate_lun(cmnd_hdr(req)->lun))
1262
if (before(cmnd_hdr(cmnd)->cmd_sn,
1263
cmnd_hdr(req)->cmd_sn))
1269
static inline char *tmf_desc(int fun)
1271
static char *tmf_desc[] = {
1277
"Logical Unit Reset",
1278
"Target Warm Reset",
1279
"Target Cold Reset",
1283
if ((fun < ISCSI_FUNCTION_ABORT_TASK) ||
1284
(fun > ISCSI_FUNCTION_TASK_REASSIGN))
1287
return tmf_desc[fun];
1290
static inline char *rsp_desc(int rsp)
1292
static char *rsp_desc[] = {
1293
"Function Complete",
1297
"Failover Unsupported",
1298
"Function Unsupported",
1300
"Function Rejected",
1304
if (((rsp < ISCSI_RESPONSE_FUNCTION_COMPLETE) ||
1305
(rsp > ISCSI_RESPONSE_NO_AUTHORIZATION)) &&
1306
(rsp != ISCSI_RESPONSE_FUNCTION_REJECTED))
1308
else if (rsp == ISCSI_RESPONSE_FUNCTION_REJECTED)
1311
return rsp_desc[rsp];
1314
static void execute_task_management(struct iscsi_cmnd *req)
1316
struct iscsi_conn *conn = req->conn;
1317
struct iscsi_session *session = conn->session;
1318
struct iscsi_target *target = session->target;
1319
struct iscsi_cmnd *rsp;
1320
struct iscsi_task_mgt_hdr *req_hdr = (struct iscsi_task_mgt_hdr *)&req->pdu.bhs;
1321
struct iscsi_task_rsp_hdr *rsp_hdr;
1323
int function = req_hdr->function & ISCSI_FUNCTION_MASK;
1325
rsp = iscsi_cmnd_create_rsp_cmnd(req, 1);
1326
rsp_hdr = (struct iscsi_task_rsp_hdr *)&rsp->pdu.bhs;
1328
rsp_hdr->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP;
1329
rsp_hdr->flags = ISCSI_FLG_FINAL;
1330
rsp_hdr->itt = req_hdr->itt;
1331
rsp_hdr->response = ISCSI_RESPONSE_FUNCTION_COMPLETE;
1334
case ISCSI_FUNCTION_ABORT_TASK:
1335
case ISCSI_FUNCTION_ABORT_TASK_SET:
1336
case ISCSI_FUNCTION_CLEAR_ACA:
1337
case ISCSI_FUNCTION_CLEAR_TASK_SET:
1338
case ISCSI_FUNCTION_LOGICAL_UNIT_RESET:
1339
lun = translate_lun(req_hdr->lun);
1340
if (!volume_lookup(target, lun)) {
1341
rsp_hdr->response = ISCSI_RESPONSE_UNKNOWN_LUN;
1347
case ISCSI_FUNCTION_ABORT_TASK:
1348
rsp_hdr->response = cmnd_abort(conn->session, req);
1350
case ISCSI_FUNCTION_ABORT_TASK_SET:
1351
task_set_abort(req);
1353
case ISCSI_FUNCTION_CLEAR_ACA:
1354
rsp_hdr->response = ISCSI_RESPONSE_FUNCTION_UNSUPPORTED;
1356
case ISCSI_FUNCTION_CLEAR_TASK_SET:
1357
rsp_hdr->response = ISCSI_RESPONSE_FUNCTION_UNSUPPORTED;
1359
case ISCSI_FUNCTION_LOGICAL_UNIT_RESET:
1360
target_reset(req, translate_lun(req_hdr->lun), 0);
1362
case ISCSI_FUNCTION_TARGET_WARM_RESET:
1363
case ISCSI_FUNCTION_TARGET_COLD_RESET:
1364
target_reset(req, 0, 1);
1365
if (function == ISCSI_FUNCTION_TARGET_COLD_RESET)
1366
set_cmnd_close(rsp);
1368
case ISCSI_FUNCTION_TASK_REASSIGN:
1369
rsp_hdr->response = ISCSI_RESPONSE_FUNCTION_UNSUPPORTED;
1372
rsp_hdr->response = ISCSI_RESPONSE_FUNCTION_REJECTED;
1376
iprintk("%s (%02x) issued on tid:%d lun:%d by sid:%llu (%s)\n",
1377
tmf_desc(function), function, target->tid,
1378
translate_lun(req_hdr->lun), session->sid,
1379
rsp_desc(rsp_hdr->response));
1381
iscsi_cmnd_init_write(rsp);
1384
static void nop_hdr_setup(struct iscsi_hdr *hdr, u8 opcode, __be32 itt,
1387
hdr->opcode = opcode;
1388
hdr->flags = ISCSI_FLG_FINAL;
1393
static void nop_out_exec(struct iscsi_cmnd *req)
1395
struct iscsi_cmnd *rsp;
1397
if (cmnd_itt(req) != cpu_to_be32(ISCSI_RESERVED_TAG)) {
1398
rsp = iscsi_cmnd_create_rsp_cmnd(req, 1);
1400
nop_hdr_setup(&rsp->pdu.bhs, ISCSI_OP_NOP_IN, req->pdu.bhs.itt,
1401
cpu_to_be32(ISCSI_RESERVED_TAG));
1403
if (req->pdu.datasize)
1410
rsp->tio = req->tio;
1413
assert(get_pgcnt(req->pdu.datasize, 0) < ISCSI_CONN_IOV_MAX);
1414
rsp->pdu.datasize = req->pdu.datasize;
1415
iscsi_cmnd_init_write(rsp);
1418
dprintk(D_GENERIC, "releasing NOP-Out %p, ttt %x; "
1419
"removing NOP-In %p, ttt %x\n", req->req,
1420
cmnd_ttt(req->req), req, cmnd_ttt(req));
1421
cmnd_release(req->req, 0);
1423
iscsi_cmnd_remove(req);
1427
static void nop_in_timeout(unsigned long data)
1429
struct iscsi_cmnd *req = (struct iscsi_cmnd *)data;
1431
printk(KERN_INFO "NOP-In ping timed out - closing sid:cid %llu:%u\n",
1432
req->conn->session->sid, req->conn->cid);
1433
clear_cmnd_timer_active(req);
1434
conn_close(req->conn);
1437
/* create a fake NOP-Out req and treat the NOP-In as our rsp to it */
1438
void send_nop_in(struct iscsi_conn *conn)
1440
struct iscsi_cmnd *req = cmnd_alloc(conn, 1);
1441
struct iscsi_cmnd *rsp = iscsi_cmnd_create_rsp_cmnd(req, 0);
1443
req->target_task_tag = get_next_ttt(conn->session);
1446
nop_hdr_setup(&req->pdu.bhs, ISCSI_OP_NOP_OUT,
1447
cpu_to_be32(ISCSI_RESERVED_TAG), req->target_task_tag);
1448
nop_hdr_setup(&rsp->pdu.bhs, ISCSI_OP_NOP_IN,
1449
cpu_to_be32(ISCSI_RESERVED_TAG), req->target_task_tag);
1451
dprintk(D_GENERIC, "NOP-Out: %p, ttt %x, timer %p; "
1452
"NOP-In: %p, ttt %x;\n", req, cmnd_ttt(req), &req->timer, rsp,
1455
init_timer(&req->timer);
1456
req->timer.data = (unsigned long)req;
1457
req->timer.function = nop_in_timeout;
1459
if (cmnd_insert_hash_ttt(req, req->target_task_tag)) {
1461
"failed to insert fake NOP-Out into hash table");
1462
cmnd_release(rsp, 0);
1463
cmnd_release(req, 0);
1465
iscsi_cmnd_init_write(rsp);
1468
static void nop_in_tx_end(struct iscsi_cmnd *cmnd)
1470
struct iscsi_conn *conn = cmnd->conn;
1473
if (cmnd->pdu.bhs.ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
1477
* NOP-In ping issued by the target.
1478
* FIXME: Sanitize the NOP timeout earlier, during configuration
1480
t = conn->session->target->trgt_param.nop_timeout;
1482
if (!t || t > conn->session->target->trgt_param.nop_interval) {
1483
eprintk("Adjusting NOPTimeout of tid %u from %u to %u "
1484
"(== NOPInterval)\n", conn->session->target->tid,
1486
conn->session->target->trgt_param.nop_interval);
1487
t = conn->session->target->trgt_param.nop_interval;
1488
conn->session->target->trgt_param.nop_timeout = t;
1491
dprintk(D_GENERIC, "NOP-In %p, %x: timer %p\n", cmnd, cmnd_ttt(cmnd),
1494
set_cmnd_timer_active(cmnd->req);
1495
mod_timer(&cmnd->req->timer, jiffies + HZ * t);
1498
static void logout_exec(struct iscsi_cmnd *req)
1500
struct iscsi_logout_req_hdr *req_hdr;
1501
struct iscsi_cmnd *rsp;
1502
struct iscsi_logout_rsp_hdr *rsp_hdr;
1504
req_hdr = (struct iscsi_logout_req_hdr *)&req->pdu.bhs;
1505
rsp = iscsi_cmnd_create_rsp_cmnd(req, 1);
1506
rsp_hdr = (struct iscsi_logout_rsp_hdr *)&rsp->pdu.bhs;
1507
rsp_hdr->opcode = ISCSI_OP_LOGOUT_RSP;
1508
rsp_hdr->flags = ISCSI_FLG_FINAL;
1509
rsp_hdr->itt = req_hdr->itt;
1510
set_cmnd_close(rsp);
1511
iscsi_cmnd_init_write(rsp);
1514
static void iscsi_cmnd_exec(struct iscsi_cmnd *cmnd)
1516
dprintk(D_GENERIC, "%p,%x,%u\n", cmnd, cmnd_opcode(cmnd), cmnd->pdu.bhs.sn);
1518
switch (cmnd_opcode(cmnd)) {
1519
case ISCSI_OP_NOP_OUT:
1522
case ISCSI_OP_SCSI_CMD:
1523
scsi_cmnd_exec(cmnd);
1525
case ISCSI_OP_SCSI_TASK_MGT_MSG:
1526
execute_task_management(cmnd);
1528
case ISCSI_OP_LOGOUT_CMD:
1531
case ISCSI_OP_SCSI_REJECT:
1532
iscsi_cmnd_init_write(get_rsp_cmnd(cmnd));
1534
case ISCSI_OP_TEXT_CMD:
1535
case ISCSI_OP_SNACK_CMD:
1538
eprintk("unexpected cmnd op %x\n", cmnd_opcode(cmnd));
1543
static void __cmnd_send_pdu(struct iscsi_conn *conn, struct tio *tio, u32 offset, u32 size)
1545
dprintk(D_GENERIC, "%p %u,%u\n", tio, offset, size);
1546
offset += tio->offset;
1548
assert(offset <= tio->offset + tio->size);
1549
assert(offset + size <= tio->offset + tio->size);
1551
conn->write_tcmnd = tio;
1552
conn->write_offset = offset;
1553
conn->write_size += size;
1556
static void cmnd_send_pdu(struct iscsi_conn *conn, struct iscsi_cmnd *cmnd)
1561
if (!cmnd->pdu.datasize)
1564
size = (cmnd->pdu.datasize + 3) & -4;
1567
assert(tio->size == size);
1568
__cmnd_send_pdu(conn, tio, 0, size);
1571
static void set_cork(struct socket *sock, int on)
1578
sock->ops->setsockopt(sock, SOL_TCP, TCP_CORK, (void *)&opt, sizeof(opt));
1582
void cmnd_release(struct iscsi_cmnd *cmnd, int force)
1584
struct iscsi_cmnd *req, *rsp;
1590
/* eprintk("%x %lx %d\n", cmnd_opcode(cmnd), cmnd->flags, force); */
1593
is_last = cmnd_final(cmnd);
1596
while (!list_empty(&cmnd->pdu_list)) {
1597
rsp = list_entry(cmnd->pdu_list.next, struct iscsi_cmnd, pdu_list);
1598
list_del_init(&rsp->list);
1599
list_del(&rsp->pdu_list);
1600
iscsi_cmnd_remove(rsp);
1602
list_del_init(&cmnd->list);
1604
if (cmnd_queued(cmnd))
1605
iscsi_scsi_dequeuecmnd(cmnd);
1607
if (cmnd_hashed(cmnd))
1608
cmnd_remove_hash(cmnd);
1610
if (cmnd_lunit(cmnd)) {
1612
volume_put(cmnd->lun);
1615
list_del_init(&cmnd->pdu_list);
1616
iscsi_cmnd_remove(cmnd);
1621
cmnd_release(req, 0);
1627
void cmnd_tx_start(struct iscsi_cmnd *cmnd)
1629
struct iscsi_conn *conn = cmnd->conn;
1632
dprintk(D_GENERIC, "%p:%x\n", cmnd, cmnd_opcode(cmnd));
1634
iscsi_cmnd_set_length(&cmnd->pdu);
1636
set_cork(conn->sock, 1);
1638
conn->write_iop = iop = conn->write_iov;
1639
iop->iov_base = &cmnd->pdu.bhs;
1640
iop->iov_len = sizeof(cmnd->pdu.bhs);
1642
conn->write_size = sizeof(cmnd->pdu.bhs);
1644
switch (cmnd_opcode(cmnd)) {
1645
case ISCSI_OP_NOP_IN:
1646
if (cmnd->pdu.bhs.itt == ISCSI_RESERVED_TAG) {
1647
/* NOP-In ping generated by us. Don't advance StatSN. */
1648
cmnd_set_sn(cmnd, 0);
1649
cmnd_set_sn(cmnd->req, 0);
1650
cmnd->pdu.bhs.sn = cpu_to_be32(conn->stat_sn);
1651
cmnd->req->pdu.bhs.sn = cpu_to_be32(conn->stat_sn);
1653
cmnd_set_sn(cmnd, 1);
1654
cmnd_send_pdu(conn, cmnd);
1656
case ISCSI_OP_SCSI_RSP:
1657
cmnd_set_sn(cmnd, 1);
1658
cmnd_send_pdu(conn, cmnd);
1660
case ISCSI_OP_SCSI_TASK_MGT_RSP:
1661
cmnd_set_sn(cmnd, 1);
1663
case ISCSI_OP_TEXT_RSP:
1664
cmnd_set_sn(cmnd, 1);
1666
case ISCSI_OP_SCSI_DATA_IN:
1668
struct iscsi_data_in_hdr *rsp = (struct iscsi_data_in_hdr *)&cmnd->pdu.bhs;
1671
cmnd_set_sn(cmnd, (rsp->flags & ISCSI_FLG_FINAL) ? 1 : 0);
1672
offset = rsp->buffer_offset;
1673
rsp->buffer_offset = cpu_to_be32(offset);
1674
__cmnd_send_pdu(conn, cmnd->tio, offset, cmnd->pdu.datasize);
1677
case ISCSI_OP_LOGOUT_RSP:
1678
cmnd_set_sn(cmnd, 1);
1681
cmnd_set_sn(cmnd, 0);
1682
cmnd->pdu.bhs.sn = cpu_to_be32(conn->stat_sn);
1684
case ISCSI_OP_ASYNC_MSG:
1685
cmnd_set_sn(cmnd, 1);
1687
case ISCSI_OP_REJECT:
1688
cmnd_set_sn(cmnd, 1);
1689
cmnd_send_pdu(conn, cmnd);
1692
eprintk("unexpected cmnd op %x\n", cmnd_opcode(cmnd));
1698
conn->write_size = (conn->write_size + 3) & -4;
1699
iscsi_dump_pdu(&cmnd->pdu);
1702
void cmnd_tx_end(struct iscsi_cmnd *cmnd)
1704
struct iscsi_conn *conn = cmnd->conn;
1706
dprintk(D_GENERIC, "%p:%x\n", cmnd, cmnd_opcode(cmnd));
1707
switch (cmnd_opcode(cmnd)) {
1708
case ISCSI_OP_NOP_IN:
1709
nop_in_tx_end(cmnd);
1711
case ISCSI_OP_SCSI_RSP:
1712
case ISCSI_OP_SCSI_TASK_MGT_RSP:
1713
case ISCSI_OP_TEXT_RSP:
1715
case ISCSI_OP_ASYNC_MSG:
1716
case ISCSI_OP_REJECT:
1717
case ISCSI_OP_SCSI_DATA_IN:
1718
case ISCSI_OP_LOGOUT_RSP:
1721
eprintk("unexpected cmnd op %x\n", cmnd_opcode(cmnd));
1726
if (cmnd_close(cmnd))
1729
list_del_init(&cmnd->list);
1730
set_cork(cmnd->conn->sock, 0);
1734
* Push the command for execution.
1735
* This functions reorders the commands.
1736
* Called from the read thread.
1738
* iscsi_session_push_cmnd -
1739
* @cmnd: ptr to command
1742
static void iscsi_session_push_cmnd(struct iscsi_cmnd *cmnd)
1744
struct iscsi_session *session = cmnd->conn->session;
1745
struct list_head *entry;
1748
if (cmnd->r2t_length) {
1749
if (!cmnd->is_unsolicited_data)
1754
dprintk(D_GENERIC, "%p:%x %u,%u\n",
1755
cmnd, cmnd_opcode(cmnd), cmnd->pdu.bhs.sn, session->exp_cmd_sn);
1757
if (cmnd_immediate(cmnd)) {
1758
iscsi_cmnd_exec(cmnd);
1762
cmd_sn = cmnd->pdu.bhs.sn;
1763
if (cmd_sn == session->exp_cmd_sn) {
1765
session->exp_cmd_sn = ++cmd_sn;
1766
iscsi_cmnd_exec(cmnd);
1768
if (list_empty(&session->pending_list))
1771
cmnd = list_entry(session->pending_list.next, struct iscsi_cmnd, list);
1772
if (cmnd->pdu.bhs.sn != cmd_sn)
1775
list_del_init(&cmnd->list);
1776
clear_cmnd_pending(cmnd);
1779
set_cmnd_pending(cmnd);
1781
list_for_each(entry, &session->pending_list) {
1782
struct iscsi_cmnd *tmp = list_entry(entry, struct iscsi_cmnd, list);
1783
if (before(cmd_sn, tmp->pdu.bhs.sn))
1787
assert(list_empty(&cmnd->list));
1789
list_add_tail(&cmnd->list, entry);
1793
static int check_segment_length(struct iscsi_cmnd *cmnd)
1795
struct iscsi_conn *conn = cmnd->conn;
1796
struct iscsi_sess_param *param = &conn->session->param;
1798
if (cmnd->pdu.datasize > param->max_recv_data_length) {
1799
eprintk("data too long %x %u %u\n", cmnd_itt(cmnd),
1800
cmnd->pdu.datasize, param->max_recv_data_length);
1802
if (get_pgcnt(cmnd->pdu.datasize, 0) > ISCSI_CONN_IOV_MAX) {
1811
void cmnd_rx_start(struct iscsi_cmnd *cmnd)
1813
struct iscsi_conn *conn = cmnd->conn;
1816
iscsi_dump_pdu(&cmnd->pdu);
1818
set_cmnd_rxstart(cmnd);
1819
if (check_segment_length(cmnd) < 0)
1822
switch (cmnd_opcode(cmnd)) {
1823
case ISCSI_OP_NOP_OUT:
1824
err = nop_out_start(conn, cmnd);
1826
case ISCSI_OP_SCSI_CMD:
1827
if (!(err = cmnd_insert_hash(cmnd)))
1828
scsi_cmnd_start(conn, cmnd);
1830
case ISCSI_OP_SCSI_TASK_MGT_MSG:
1831
err = cmnd_insert_hash(cmnd);
1833
case ISCSI_OP_SCSI_DATA_OUT:
1834
data_out_start(conn, cmnd);
1836
case ISCSI_OP_LOGOUT_CMD:
1837
err = cmnd_insert_hash(cmnd);
1839
case ISCSI_OP_TEXT_CMD:
1840
case ISCSI_OP_SNACK_CMD:
1841
err = -ISCSI_REASON_UNSUPPORTED_COMMAND;
1844
err = -ISCSI_REASON_UNSUPPORTED_COMMAND;
1849
eprintk("%x %x %d\n", cmnd_opcode(cmnd), cmnd_itt(cmnd), err);
1850
iscsi_cmnd_reject(cmnd, -err);
1854
void cmnd_rx_end(struct iscsi_cmnd *cmnd)
1856
struct iscsi_conn *conn = cmnd->conn;
1858
if (cmnd_tmfabort(cmnd)) {
1859
cmnd_release(cmnd, 1);
1863
dprintk(D_GENERIC, "%p:%x\n", cmnd, cmnd_opcode(cmnd));
1864
switch (cmnd_opcode(cmnd)) {
1865
case ISCSI_OP_SCSI_REJECT:
1866
case ISCSI_OP_NOP_OUT:
1867
case ISCSI_OP_SCSI_CMD:
1868
case ISCSI_OP_SCSI_TASK_MGT_MSG:
1869
case ISCSI_OP_TEXT_CMD:
1870
case ISCSI_OP_LOGOUT_CMD:
1871
iscsi_session_push_cmnd(cmnd);
1873
case ISCSI_OP_SCSI_DATA_OUT:
1874
data_out_end(conn, cmnd);
1876
case ISCSI_OP_SNACK_CMD:
1878
case ISCSI_OP_PDU_REJECT:
1879
iscsi_cmnd_init_write(get_rsp_cmnd(cmnd));
1881
case ISCSI_OP_DATA_REJECT:
1882
cmnd_release(cmnd, 0);
1885
eprintk("unexpected cmnd op %x\n", cmnd_opcode(cmnd));
1891
static void iscsi_exit(void)
1893
wthread_module_exit();
1895
unregister_chrdev(ctr_major, ctr_name);
1907
if (iscsi_cmnd_cache)
1908
kmem_cache_destroy(iscsi_cmnd_cache);
1911
static int iscsi_init(void)
1915
printk("iSCSI Enterprise Target Software - version %s\n", IET_VERSION_STRING);
1917
if ((ctr_major = register_chrdev(0, ctr_name, &ctr_fops)) < 0) {
1918
eprintk("failed to register the control device %d\n", ctr_major);
1922
if ((err = iet_procfs_init()) < 0)
1925
if ((err = event_init()) < 0)
1928
iscsi_cmnd_cache = KMEM_CACHE(iscsi_cmnd, 0);
1929
if (!iscsi_cmnd_cache)
1936
if ((err = tio_init()) < 0)
1939
if ((err = iotype_init()) < 0)
1942
if ((err = wthread_module_init()) < 0)
1952
module_param(worker_thread_pool_size, ulong, S_IRUGO);
1953
MODULE_PARM_DESC(worker_thread_pool_size,
1954
"Size of the worker thread pool "
1955
"(0 = dedicated threads per target (default))");
1957
module_param(debug_enable_flags, ulong, S_IRUGO | S_IWUSR);
1958
MODULE_PARM_DESC(debug_enable_flags,
1959
"debug bitmask, low bits (0 ... 8) used, see iscsi_dbg.h");
1961
module_init(iscsi_init);
1962
module_exit(iscsi_exit);
1964
MODULE_VERSION(IET_VERSION_STRING);
1965
MODULE_LICENSE("GPL");
1966
MODULE_DESCRIPTION("iSCSI Enterprise Target");
1967
MODULE_AUTHOR("IET development team <iscsitarget-devel@lists.sourceforge.net>");
added
removed
ubuntu/iscsitarget/iscsi.c
