drivers/target/iscsi/iscsi_target_seq_pdu_list.c

   1 /*******************************************************************************
   2  * This file contains main functions related to iSCSI DataSequenceInOrder=No
   3  * and DataPDUInOrder=No.
   4  *
   5  \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
   6  *
   7  * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
   8  *
   9  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  ******************************************************************************/
  21
  22 #include <linux/slab.h>
  23 #include <linux/random.h>
  24
  25 #include "iscsi_target_core.h"
  26 #include "iscsi_target_util.h"
  27 #include "iscsi_target_seq_pdu_list.h"
  28
  29 #define OFFLOAD_BUF_SIZE        32768
  30
  31 void iscsit_dump_seq_list(struct iscsi_cmd *cmd)
  32 {
  33         int i;
  34         struct iscsi_seq *seq;
  35
  36         pr_debug("Dumping Sequence List for ITT: 0x%08x:\n",
  37                         cmd->init_task_tag);
  38
  39         for (i = 0; i < cmd->seq_count; i++) {
  40                 seq = &cmd->seq_list[i];
  41                 pr_debug("i: %d, pdu_start: %d, pdu_count: %d,"
  42                         " offset: %d, xfer_len: %d, seq_send_order: %d,"
  43                         " seq_no: %d\n", i, seq->pdu_start, seq->pdu_count,
  44                         seq->offset, seq->xfer_len, seq->seq_send_order,
  45                         seq->seq_no);
  46         }
  47 }
  48
  49 void iscsit_dump_pdu_list(struct iscsi_cmd *cmd)
  50 {
  51         int i;
  52         struct iscsi_pdu *pdu;
  53
  54         pr_debug("Dumping PDU List for ITT: 0x%08x:\n",
  55                         cmd->init_task_tag);
  56
  57         for (i = 0; i < cmd->pdu_count; i++) {
  58                 pdu = &cmd->pdu_list[i];
  59                 pr_debug("i: %d, offset: %d, length: %d,"
  60                         " pdu_send_order: %d, seq_no: %d\n", i, pdu->offset,
  61                         pdu->length, pdu->pdu_send_order, pdu->seq_no);
  62         }
  63 }
  64
  65 static void iscsit_ordered_seq_lists(
  66         struct iscsi_cmd *cmd,
  67         u8 type)
  68 {
  69         u32 i, seq_count = 0;
  70
  71         for (i = 0; i < cmd->seq_count; i++) {
  72                 if (cmd->seq_list[i].type != SEQTYPE_NORMAL)
  73                         continue;
  74                 cmd->seq_list[i].seq_send_order = seq_count++;
  75         }
  76 }
  77
  78 static void iscsit_ordered_pdu_lists(
  79         struct iscsi_cmd *cmd,
  80         u8 type)
  81 {
  82         u32 i, pdu_send_order = 0, seq_no = 0;
  83
  84         for (i = 0; i < cmd->pdu_count; i++) {
  85 redo:
  86                 if (cmd->pdu_list[i].seq_no == seq_no) {
  87                         cmd->pdu_list[i].pdu_send_order = pdu_send_order++;
  88                         continue;
  89                 }
  90                 seq_no++;
  91                 pdu_send_order = 0;
  92                 goto redo;
  93         }
  94 }
  95
  96 /*
  97  *      Generate count random values into array.
  98  *      Use 0x80000000 to mark generates valued in array[].
  99  */
 100 static void iscsit_create_random_array(u32 *array, u32 count)
 101 {
 102         int i, j, k;
 103
 104         if (count == 1) {
 105                 array[0] = 0;
 106                 return;
 107         }
 108
 109         for (i = 0; i < count; i++) {
 110 redo:
 111                 get_random_bytes(&j, sizeof(u32));
 112                 j = (1 + (int) (9999 + 1) - j) % count;
 113                 for (k = 0; k < i + 1; k++) {
 114                         j |= 0x80000000;
 115                         if ((array[k] & 0x80000000) && (array[k] == j))
 116                                 goto redo;
 117                 }
 118                 array[i] = j;
 119         }
 120
 121         for (i = 0; i < count; i++)
 122                 array[i] &= ~0x80000000;
 123 }
 124
 125 static int iscsit_randomize_pdu_lists(
 126         struct iscsi_cmd *cmd,
 127         u8 type)
 128 {
 129         int i = 0;
 130         u32 *array, pdu_count, seq_count = 0, seq_no = 0, seq_offset = 0;
 131
 132         for (pdu_count = 0; pdu_count < cmd->pdu_count; pdu_count++) {
 133 redo:
 134                 if (cmd->pdu_list[pdu_count].seq_no == seq_no) {
 135                         seq_count++;
 136                         continue;
 137                 }
 138                 array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL);
 139                 if (!array) {
 140                         pr_err("Unable to allocate memory"
 141                                 " for random array.\n");
 142                         return -1;
 143                 }
 144                 iscsit_create_random_array(array, seq_count);
 145
 146                 for (i = 0; i < seq_count; i++)
 147                         cmd->pdu_list[seq_offset+i].pdu_send_order = array[i];
 148
 149                 kfree(array);
 150
 151                 seq_offset += seq_count;
 152                 seq_count = 0;
 153                 seq_no++;
 154                 goto redo;
 155         }
 156
 157         if (seq_count) {
 158                 array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL);
 159                 if (!array) {
 160                         pr_err("Unable to allocate memory for"
 161                                 " random array.\n");
 162                         return -1;
 163                 }
 164                 iscsit_create_random_array(array, seq_count);
 165
 166                 for (i = 0; i < seq_count; i++)
 167                         cmd->pdu_list[seq_offset+i].pdu_send_order = array[i];
 168
 169                 kfree(array);
 170         }
 171
 172         return 0;
 173 }
 174
 175 static int iscsit_randomize_seq_lists(
 176         struct iscsi_cmd *cmd,
 177         u8 type)
 178 {
 179         int i, j = 0;
 180         u32 *array, seq_count = cmd->seq_count;
 181
 182         if ((type == PDULIST_IMMEDIATE) || (type == PDULIST_UNSOLICITED))
 183                 seq_count--;
 184         else if (type == PDULIST_IMMEDIATE_AND_UNSOLICITED)
 185                 seq_count -= 2;
 186
 187         if (!seq_count)
 188                 return 0;
 189
 190         array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL);
 191         if (!array) {
 192                 pr_err("Unable to allocate memory for random array.\n");
 193                 return -1;
 194         }
 195         iscsit_create_random_array(array, seq_count);
 196
 197         for (i = 0; i < cmd->seq_count; i++) {
 198                 if (cmd->seq_list[i].type != SEQTYPE_NORMAL)
 199                         continue;
 200                 cmd->seq_list[i].seq_send_order = array[j++];
 201         }
 202
 203         kfree(array);
 204         return 0;
 205 }
 206
 207 static void iscsit_determine_counts_for_list(
 208         struct iscsi_cmd *cmd,
 209         struct iscsi_build_list *bl,
 210         u32 *seq_count,
 211         u32 *pdu_count)
 212 {
 213         int check_immediate = 0;
 214         u32 burstlength = 0, offset = 0;
 215         u32 unsolicited_data_length = 0;
 216         struct iscsi_conn *conn = cmd->conn;
 217
 218         if ((bl->type == PDULIST_IMMEDIATE) ||
 219             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
 220                 check_immediate = 1;
 221
 222         if ((bl->type == PDULIST_UNSOLICITED) ||
 223             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
 224                 unsolicited_data_length = (cmd->data_length >
 225                         conn->sess->sess_ops->FirstBurstLength) ?
 226                         conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
 227
 228         while (offset < cmd->data_length) {
 229                 *pdu_count += 1;
 230
 231                 if (check_immediate) {
 232                         check_immediate = 0;
 233                         offset += bl->immediate_data_length;
 234                         *seq_count += 1;
 235                         if (unsolicited_data_length)
 236                                 unsolicited_data_length -=
 237                                         bl->immediate_data_length;
 238                         continue;
 239                 }
 240                 if (unsolicited_data_length > 0) {
 241                         if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
 242                                         >= cmd->data_length) {
 243                                 unsolicited_data_length -=
 244                                         (cmd->data_length - offset);
 245                                 offset += (cmd->data_length - offset);
 246                                 continue;
 247                         }
 248                         if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
 249                                         >= conn->sess->sess_ops->FirstBurstLength) {
 250                                 unsolicited_data_length -=
 251                                         (conn->sess->sess_ops->FirstBurstLength -
 252                                         offset);
 253                                 offset += (conn->sess->sess_ops->FirstBurstLength -
 254                                         offset);
 255                                 burstlength = 0;
 256                                 *seq_count += 1;
 257                                 continue;
 258                         }
 259
 260                         offset += conn->conn_ops->MaxRecvDataSegmentLength;
 261                         unsolicited_data_length -=
 262                                 conn->conn_ops->MaxRecvDataSegmentLength;
 263                         continue;
 264                 }
 265                 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
 266                      cmd->data_length) {
 267                         offset += (cmd->data_length - offset);
 268                         continue;
 269                 }
 270                 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
 271                      conn->sess->sess_ops->MaxBurstLength) {
 272                         offset += (conn->sess->sess_ops->MaxBurstLength -
 273                                         burstlength);
 274                         burstlength = 0;
 275                         *seq_count += 1;
 276                         continue;
 277                 }
 278
 279                 burstlength += conn->conn_ops->MaxRecvDataSegmentLength;
 280                 offset += conn->conn_ops->MaxRecvDataSegmentLength;
 281         }
 282 }
 283
 284
 285 /*
 286  *      Builds PDU and/or Sequence list,  called while DataSequenceInOrder=No
 287  *      and DataPDUInOrder=No.
 288  */
 289 static int iscsit_build_pdu_and_seq_list(
 290         struct iscsi_cmd *cmd,
 291         struct iscsi_build_list *bl)
 292 {
 293         int check_immediate = 0, datapduinorder, datasequenceinorder;
 294         u32 burstlength = 0, offset = 0, i = 0;
 295         u32 pdu_count = 0, seq_no = 0, unsolicited_data_length = 0;
 296         struct iscsi_conn *conn = cmd->conn;
 297         struct iscsi_pdu *pdu = cmd->pdu_list;
 298         struct iscsi_seq *seq = cmd->seq_list;
 299
 300         datapduinorder = conn->sess->sess_ops->DataPDUInOrder;
 301         datasequenceinorder = conn->sess->sess_ops->DataSequenceInOrder;
 302
 303         if ((bl->type == PDULIST_IMMEDIATE) ||
 304             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
 305                 check_immediate = 1;
 306
 307         if ((bl->type == PDULIST_UNSOLICITED) ||
 308             (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
 309                 unsolicited_data_length = (cmd->data_length >
 310                         conn->sess->sess_ops->FirstBurstLength) ?
 311                         conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
 312
 313         while (offset < cmd->data_length) {
 314                 pdu_count++;
 315                 if (!datapduinorder) {
 316                         pdu[i].offset = offset;
 317                         pdu[i].seq_no = seq_no;
 318                 }
 319                 if (!datasequenceinorder && (pdu_count == 1)) {
 320                         seq[seq_no].pdu_start = i;
 321                         seq[seq_no].seq_no = seq_no;
 322                         seq[seq_no].offset = offset;
 323                         seq[seq_no].orig_offset = offset;
 324                 }
 325
 326                 if (check_immediate) {
 327                         check_immediate = 0;
 328                         if (!datapduinorder) {
 329                                 pdu[i].type = PDUTYPE_IMMEDIATE;
 330                                 pdu[i++].length = bl->immediate_data_length;
 331                         }
 332                         if (!datasequenceinorder) {
 333                                 seq[seq_no].type = SEQTYPE_IMMEDIATE;
 334                                 seq[seq_no].pdu_count = 1;
 335                                 seq[seq_no].xfer_len =
 336                                         bl->immediate_data_length;
 337                         }
 338                         offset += bl->immediate_data_length;
 339                         pdu_count = 0;
 340                         seq_no++;
 341                         if (unsolicited_data_length)
 342                                 unsolicited_data_length -=
 343                                         bl->immediate_data_length;
 344                         continue;
 345                 }
 346                 if (unsolicited_data_length > 0) {
 347                         if ((offset +
 348                              conn->conn_ops->MaxRecvDataSegmentLength) >=
 349                              cmd->data_length) {
 350                                 if (!datapduinorder) {
 351                                         pdu[i].type = PDUTYPE_UNSOLICITED;
 352                                         pdu[i].length =
 353                                                 (cmd->data_length - offset);
 354                                 }
 355                                 if (!datasequenceinorder) {
 356                                         seq[seq_no].type = SEQTYPE_UNSOLICITED;
 357                                         seq[seq_no].pdu_count = pdu_count;
 358                                         seq[seq_no].xfer_len = (burstlength +
 359                                                 (cmd->data_length - offset));
 360                                 }
 361                                 unsolicited_data_length -=
 362                                                 (cmd->data_length - offset);
 363                                 offset += (cmd->data_length - offset);
 364                                 continue;
 365                         }
 366                         if ((offset +
 367                              conn->conn_ops->MaxRecvDataSegmentLength) >=
 368                                         conn->sess->sess_ops->FirstBurstLength) {
 369                                 if (!datapduinorder) {
 370                                         pdu[i].type = PDUTYPE_UNSOLICITED;
 371                                         pdu[i++].length =
 372                                            (conn->sess->sess_ops->FirstBurstLength -
 373                                                 offset);
 374                                 }
 375                                 if (!datasequenceinorder) {
 376                                         seq[seq_no].type = SEQTYPE_UNSOLICITED;
 377                                         seq[seq_no].pdu_count = pdu_count;
 378                                         seq[seq_no].xfer_len = (burstlength +
 379                                            (conn->sess->sess_ops->FirstBurstLength -
 380                                                 offset));
 381                                 }
 382                                 unsolicited_data_length -=
 383                                         (conn->sess->sess_ops->FirstBurstLength -
 384                                                 offset);
 385                                 offset += (conn->sess->sess_ops->FirstBurstLength -
 386                                                 offset);
 387                                 burstlength = 0;
 388                                 pdu_count = 0;
 389                                 seq_no++;
 390                                 continue;
 391                         }
 392
 393                         if (!datapduinorder) {
 394                                 pdu[i].type = PDUTYPE_UNSOLICITED;
 395                                 pdu[i++].length =
 396                                      conn->conn_ops->MaxRecvDataSegmentLength;
 397                         }
 398                         burstlength += conn->conn_ops->MaxRecvDataSegmentLength;
 399                         offset += conn->conn_ops->MaxRecvDataSegmentLength;
 400                         unsolicited_data_length -=
 401                                 conn->conn_ops->MaxRecvDataSegmentLength;
 402                         continue;
 403                 }
 404                 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
 405                      cmd->data_length) {
 406                         if (!datapduinorder) {
 407                                 pdu[i].type = PDUTYPE_NORMAL;
 408                                 pdu[i].length = (cmd->data_length - offset);
 409                         }
 410                         if (!datasequenceinorder) {
 411                                 seq[seq_no].type = SEQTYPE_NORMAL;
 412                                 seq[seq_no].pdu_count = pdu_count;
 413                                 seq[seq_no].xfer_len = (burstlength +
 414                                         (cmd->data_length - offset));
 415                         }
 416                         offset += (cmd->data_length - offset);
 417                         continue;
 418                 }
 419                 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
 420                      conn->sess->sess_ops->MaxBurstLength) {
 421                         if (!datapduinorder) {
 422                                 pdu[i].type = PDUTYPE_NORMAL;
 423                                 pdu[i++].length =
 424                                         (conn->sess->sess_ops->MaxBurstLength -
 425                                                 burstlength);
 426                         }
 427                         if (!datasequenceinorder) {
 428                                 seq[seq_no].type = SEQTYPE_NORMAL;
 429                                 seq[seq_no].pdu_count = pdu_count;
 430                                 seq[seq_no].xfer_len = (burstlength +
 431                                         (conn->sess->sess_ops->MaxBurstLength -
 432                                         burstlength));
 433                         }
 434                         offset += (conn->sess->sess_ops->MaxBurstLength -
 435                                         burstlength);
 436                         burstlength = 0;
 437                         pdu_count = 0;
 438                         seq_no++;
 439                         continue;
 440                 }
 441
 442                 if (!datapduinorder) {
 443                         pdu[i].type = PDUTYPE_NORMAL;
 444                         pdu[i++].length =
 445                                 conn->conn_ops->MaxRecvDataSegmentLength;
 446                 }
 447                 burstlength += conn->conn_ops->MaxRecvDataSegmentLength;
 448                 offset += conn->conn_ops->MaxRecvDataSegmentLength;
 449         }
 450
 451         if (!datasequenceinorder) {
 452                 if (bl->data_direction & ISCSI_PDU_WRITE) {
 453                         if (bl->randomize & RANDOM_R2T_OFFSETS) {
 454                                 if (iscsit_randomize_seq_lists(cmd, bl->type)
 455                                                 < 0)
 456                                         return -1;
 457                         } else
 458                                 iscsit_ordered_seq_lists(cmd, bl->type);
 459                 } else if (bl->data_direction & ISCSI_PDU_READ) {
 460                         if (bl->randomize & RANDOM_DATAIN_SEQ_OFFSETS) {
 461                                 if (iscsit_randomize_seq_lists(cmd, bl->type)
 462                                                 < 0)
 463                                         return -1;
 464                         } else
 465                                 iscsit_ordered_seq_lists(cmd, bl->type);
 466                 }
 467 #if 0
 468                 iscsit_dump_seq_list(cmd);
 469 #endif
 470         }
 471         if (!datapduinorder) {
 472                 if (bl->data_direction & ISCSI_PDU_WRITE) {
 473                         if (bl->randomize & RANDOM_DATAOUT_PDU_OFFSETS) {
 474                                 if (iscsit_randomize_pdu_lists(cmd, bl->type)
 475                                                 < 0)
 476                                         return -1;
 477                         } else
 478                                 iscsit_ordered_pdu_lists(cmd, bl->type);
 479                 } else if (bl->data_direction & ISCSI_PDU_READ) {
 480                         if (bl->randomize & RANDOM_DATAIN_PDU_OFFSETS) {
 481                                 if (iscsit_randomize_pdu_lists(cmd, bl->type)
 482                                                 < 0)
 483                                         return -1;
 484                         } else
 485                                 iscsit_ordered_pdu_lists(cmd, bl->type);
 486                 }
 487 #if 0
 488                 iscsit_dump_pdu_list(cmd);
 489 #endif
 490         }
 491
 492         return 0;
 493 }
 494
 495 /*
 496  *      Only called while DataSequenceInOrder=No or DataPDUInOrder=No.
 497  */
 498 int iscsit_do_build_list(
 499         struct iscsi_cmd *cmd,
 500         struct iscsi_build_list *bl)
 501 {
 502         u32 pdu_count = 0, seq_count = 1;
 503         struct iscsi_conn *conn = cmd->conn;
 504         struct iscsi_pdu *pdu = NULL;
 505         struct iscsi_seq *seq = NULL;
 506
 507         iscsit_determine_counts_for_list(cmd, bl, &seq_count, &pdu_count);
 508
 509         if (!conn->sess->sess_ops->DataSequenceInOrder) {
 510                 seq = kzalloc(seq_count * sizeof(struct iscsi_seq), GFP_ATOMIC);
 511                 if (!seq) {
 512                         pr_err("Unable to allocate struct iscsi_seq list\n");
 513                         return -1;
 514                 }
 515                 cmd->seq_list = seq;
 516                 cmd->seq_count = seq_count;
 517         }
 518
 519         if (!conn->sess->sess_ops->DataPDUInOrder) {
 520                 pdu = kzalloc(pdu_count * sizeof(struct iscsi_pdu), GFP_ATOMIC);
 521                 if (!pdu) {
 522                         pr_err("Unable to allocate struct iscsi_pdu list.\n");
 523                         kfree(seq);
 524                         return -1;
 525                 }
 526                 cmd->pdu_list = pdu;
 527                 cmd->pdu_count = pdu_count;
 528         }
 529
 530         return iscsit_build_pdu_and_seq_list(cmd, bl);
 531 }
 532
 533 struct iscsi_pdu *iscsit_get_pdu_holder(
 534         struct iscsi_cmd *cmd,
 535         u32 offset,
 536         u32 length)
 537 {
 538         u32 i;
 539         struct iscsi_pdu *pdu = NULL;
 540
 541         if (!cmd->pdu_list) {
 542                 pr_err("struct iscsi_cmd->pdu_list is NULL!\n");
 543                 return NULL;
 544         }
 545
 546         pdu = &cmd->pdu_list[0];
 547
 548         for (i = 0; i < cmd->pdu_count; i++)
 549                 if ((pdu[i].offset == offset) && (pdu[i].length == length))
 550                         return &pdu[i];
 551
 552         pr_err("Unable to locate PDU holder for ITT: 0x%08x, Offset:"
 553                 " %u, Length: %u\n", cmd->init_task_tag, offset, length);
 554         return NULL;
 555 }
 556
 557 struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(
 558         struct iscsi_cmd *cmd,
 559         struct iscsi_seq *seq)
 560 {
 561         u32 i;
 562         struct iscsi_conn *conn = cmd->conn;
 563         struct iscsi_pdu *pdu = NULL;
 564
 565         if (!cmd->pdu_list) {
 566                 pr_err("struct iscsi_cmd->pdu_list is NULL!\n");
 567                 return NULL;
 568         }
 569
 570         if (conn->sess->sess_ops->DataSequenceInOrder) {
 571 redo:
 572                 pdu = &cmd->pdu_list[cmd->pdu_start];
 573
 574                 for (i = 0; pdu[i].seq_no != cmd->seq_no; i++) {
 575 #if 0
 576                         pr_debug("pdu[i].seq_no: %d, pdu[i].pdu"
 577                                 "_send_order: %d, pdu[i].offset: %d,"
 578                                 " pdu[i].length: %d\n", pdu[i].seq_no,
 579                                 pdu[i].pdu_send_order, pdu[i].offset,
 580                                 pdu[i].length);
 581 #endif
 582                         if (pdu[i].pdu_send_order == cmd->pdu_send_order) {
 583                                 cmd->pdu_send_order++;
 584                                 return &pdu[i];
 585                         }
 586                 }
 587
 588                 cmd->pdu_start += cmd->pdu_send_order;
 589                 cmd->pdu_send_order = 0;
 590                 cmd->seq_no++;
 591
 592                 if (cmd->pdu_start < cmd->pdu_count)
 593                         goto redo;
 594
 595                 pr_err("Command ITT: 0x%08x unable to locate"
 596                         " struct iscsi_pdu for cmd->pdu_send_order: %u.\n",
 597                         cmd->init_task_tag, cmd->pdu_send_order);
 598                 return NULL;
 599         } else {
 600                 if (!seq) {
 601                         pr_err("struct iscsi_seq is NULL!\n");
 602                         return NULL;
 603                 }
 604 #if 0
 605                 pr_debug("seq->pdu_start: %d, seq->pdu_count: %d,"
 606                         " seq->seq_no: %d\n", seq->pdu_start, seq->pdu_count,
 607                         seq->seq_no);
 608 #endif
 609                 pdu = &cmd->pdu_list[seq->pdu_start];
 610
 611                 if (seq->pdu_send_order == seq->pdu_count) {
 612                         pr_err("Command ITT: 0x%08x seq->pdu_send"
 613                                 "_order: %u equals seq->pdu_count: %u\n",
 614                                 cmd->init_task_tag, seq->pdu_send_order,
 615                                 seq->pdu_count);
 616                         return NULL;
 617                 }
 618
 619                 for (i = 0; i < seq->pdu_count; i++) {
 620                         if (pdu[i].pdu_send_order == seq->pdu_send_order) {
 621                                 seq->pdu_send_order++;
 622                                 return &pdu[i];
 623                         }
 624                 }
 625
 626                 pr_err("Command ITT: 0x%08x unable to locate iscsi"
 627                         "_pdu_t for seq->pdu_send_order: %u.\n",
 628                         cmd->init_task_tag, seq->pdu_send_order);
 629                 return NULL;
 630         }
 631
 632         return NULL;
 633 }
 634
 635 struct iscsi_seq *iscsit_get_seq_holder(
 636         struct iscsi_cmd *cmd,
 637         u32 offset,
 638         u32 length)
 639 {
 640         u32 i;
 641
 642         if (!cmd->seq_list) {
 643                 pr_err("struct iscsi_cmd->seq_list is NULL!\n");
 644                 return NULL;
 645         }
 646
 647         for (i = 0; i < cmd->seq_count; i++) {
 648 #if 0
 649                 pr_debug("seq_list[i].orig_offset: %d, seq_list[i]."
 650                         "xfer_len: %d, seq_list[i].seq_no %u\n",
 651                         cmd->seq_list[i].orig_offset, cmd->seq_list[i].xfer_len,
 652                         cmd->seq_list[i].seq_no);
 653 #endif
 654                 if ((cmd->seq_list[i].orig_offset +
 655                                 cmd->seq_list[i].xfer_len) >=
 656                                 (offset + length))
 657                         return &cmd->seq_list[i];
 658         }
 659
 660         pr_err("Unable to locate Sequence holder for ITT: 0x%08x,"
 661                 " Offset: %u, Length: %u\n", cmd->init_task_tag, offset,
 662                 length);
 663         return NULL;
 664 }