Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending

+4 -25

drivers/infiniband/ulp/isert/ib_isert.c

··· 3095 3095 3096 3096 static int 3097 3097 isert_setup_np(struct iscsi_np *np, 3098 - struct __kernel_sockaddr_storage *ksockaddr) 3098 + struct sockaddr_storage *ksockaddr) 3099 3099 { 3100 3100 struct isert_np *isert_np; 3101 3101 struct rdma_cm_id *isert_lid; ··· 3117 3117 * in iscsi_target_configfs.c code.. 3118 3118 */ 3119 3119 memcpy(&np->np_sockaddr, ksockaddr, 3120 - sizeof(struct __kernel_sockaddr_storage)); 3120 + sizeof(struct sockaddr_storage)); 3121 3121 3122 3122 isert_lid = isert_setup_id(isert_np); 3123 3123 if (IS_ERR(isert_lid)) { ··· 3199 3199 { 3200 3200 struct rdma_cm_id *cm_id = isert_conn->cm_id; 3201 3201 struct rdma_route *cm_route = &cm_id->route; 3202 - struct sockaddr_in *sock_in; 3203 - struct sockaddr_in6 *sock_in6; 3204 3202 3205 3203 conn->login_family = np->np_sockaddr.ss_family; 3206 3204 3207 - if (np->np_sockaddr.ss_family == AF_INET6) { 3208 - sock_in6 = (struct sockaddr_in6 *)&cm_route->addr.dst_addr; 3209 - snprintf(conn->login_ip, sizeof(conn->login_ip), "%pI6c", 3210 - &sock_in6->sin6_addr.in6_u); 3211 - conn->login_port = ntohs(sock_in6->sin6_port); 3212 - 3213 - sock_in6 = (struct sockaddr_in6 *)&cm_route->addr.src_addr; 3214 - snprintf(conn->local_ip, sizeof(conn->local_ip), "%pI6c", 3215 - &sock_in6->sin6_addr.in6_u); 3216 - conn->local_port = ntohs(sock_in6->sin6_port); 3217 - } else { 3218 - sock_in = (struct sockaddr_in *)&cm_route->addr.dst_addr; 3219 - sprintf(conn->login_ip, "%pI4", 3220 - &sock_in->sin_addr.s_addr); 3221 - conn->login_port = ntohs(sock_in->sin_port); 3222 - 3223 - sock_in = (struct sockaddr_in *)&cm_route->addr.src_addr; 3224 - sprintf(conn->local_ip, "%pI4", 3225 - &sock_in->sin_addr.s_addr); 3226 - conn->local_port = ntohs(sock_in->sin_port); 3227 - } 3205 + conn->login_sockaddr = cm_route->addr.dst_addr; 3206 + conn->local_sockaddr = cm_route->addr.src_addr; 3228 3207 } 3229 3208 3230 3209 static int

+3 -6

drivers/scsi/libiscsi.c

··· 853 853 SAM_STAT_CHECK_CONDITION; 854 854 scsi_build_sense_buffer(1, sc->sense_buffer, 855 855 ILLEGAL_REQUEST, 0x10, ascq); 856 - sc->sense_buffer[7] = 0xc; /* Additional sense length */ 857 - sc->sense_buffer[8] = 0; /* Information desc type */ 858 - sc->sense_buffer[9] = 0xa; /* Additional desc length */ 859 - sc->sense_buffer[10] = 0x80; /* Validity bit */ 860 - 861 - put_unaligned_be64(sector, &sc->sense_buffer[12]); 856 + scsi_set_sense_information(sc->sense_buffer, 857 + SCSI_SENSE_BUFFERSIZE, 858 + sector); 862 859 goto out; 863 860 } 864 861 }

+2 -2

drivers/scsi/qla2xxx/Kconfig

··· 32 32 They are also included in the linux-firmware tree as well. 33 33 34 34 config TCM_QLA2XXX 35 - tristate "TCM_QLA2XXX fabric module for Qlogic 2xxx series target mode HBAs" 35 + tristate "TCM_QLA2XXX fabric module for QLogic 24xx+ series target mode HBAs" 36 36 depends on SCSI_QLA_FC && TARGET_CORE 37 37 depends on LIBFC 38 38 select BTREE 39 39 default n 40 40 ---help--- 41 - Say Y here to enable the TCM_QLA2XXX fabric module for Qlogic 2xxx series target mode HBAs 41 + Say Y here to enable the TCM_QLA2XXX fabric module for QLogic 24xx+ series target mode HBAs

+6 -7

drivers/scsi/qla2xxx/tcm_qla2xxx.c

··· 1359 1359 struct qla_hw_data *ha = tgt->ha; 1360 1360 scsi_qla_host_t *vha = pci_get_drvdata(ha->pdev); 1361 1361 struct se_session *se_sess; 1362 - struct se_node_acl *se_nacl; 1363 1362 struct tcm_qla2xxx_lport *lport; 1364 - struct tcm_qla2xxx_nacl *nacl; 1365 1363 1366 1364 BUG_ON(in_interrupt()); 1367 1365 ··· 1369 1371 dump_stack(); 1370 1372 return; 1371 1373 } 1372 - se_nacl = se_sess->se_node_acl; 1373 - nacl = container_of(se_nacl, struct tcm_qla2xxx_nacl, se_node_acl); 1374 1374 1375 1375 lport = vha->vha_tgt.target_lport_ptr; 1376 1376 if (!lport) { ··· 1676 1680 (struct tcm_qla2xxx_lport *)target_lport_ptr; 1677 1681 struct tcm_qla2xxx_lport *base_lport = 1678 1682 (struct tcm_qla2xxx_lport *)base_vha->vha_tgt.target_lport_ptr; 1679 - struct tcm_qla2xxx_tpg *base_tpg; 1680 1683 struct fc_vport_identifiers vport_id; 1681 1684 1682 1685 if (!qla_tgt_mode_enabled(base_vha)) { ··· 1688 1693 pr_err("qla2xxx base_lport or tpg_1 not available\n"); 1689 1694 return -EPERM; 1690 1695 } 1691 - base_tpg = base_lport->tpg_1; 1692 1696 1693 1697 memset(&vport_id, 0, sizeof(vport_id)); 1694 1698 vport_id.port_name = npiv_wwpn; ··· 1804 1810 .module = THIS_MODULE, 1805 1811 .name = "qla2xxx", 1806 1812 .node_acl_size = sizeof(struct tcm_qla2xxx_nacl), 1813 + /* 1814 + * XXX: Limit assumes single page per scatter-gather-list entry. 1815 + * Current maximum is ~4.9 MB per se_cmd->t_data_sg with PAGE_SIZE=4096 1816 + */ 1817 + .max_data_sg_nents = 1200, 1807 1818 .get_fabric_name = tcm_qla2xxx_get_fabric_name, 1808 1819 .tpg_get_wwn = tcm_qla2xxx_get_fabric_wwn, 1809 1820 .tpg_get_tag = tcm_qla2xxx_get_tag, ··· 1957 1958 tcm_qla2xxx_deregister_configfs(); 1958 1959 } 1959 1960 1960 - MODULE_DESCRIPTION("TCM QLA2XXX series NPIV enabled fabric driver"); 1961 + MODULE_DESCRIPTION("TCM QLA24XX+ series NPIV enabled fabric driver"); 1961 1962 MODULE_LICENSE("GPL"); 1962 1963 module_init(tcm_qla2xxx_init); 1963 1964 module_exit(tcm_qla2xxx_exit);

+109

drivers/scsi/scsi_common.c

··· 5 5 #include <linux/bug.h> 6 6 #include <linux/kernel.h> 7 7 #include <linux/string.h> 8 + #include <linux/errno.h> 9 + #include <asm/unaligned.h> 8 10 #include <scsi/scsi_common.h> 9 11 10 12 /* NB: These are exposed through /proc/scsi/scsi and form part of the ABI. ··· 178 176 return true; 179 177 } 180 178 EXPORT_SYMBOL(scsi_normalize_sense); 179 + 180 + /** 181 + * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format. 182 + * @sense_buffer: byte array of descriptor format sense data 183 + * @sb_len: number of valid bytes in sense_buffer 184 + * @desc_type: value of descriptor type to find 185 + * (e.g. 0 -> information) 186 + * 187 + * Notes: 188 + * only valid when sense data is in descriptor format 189 + * 190 + * Return value: 191 + * pointer to start of (first) descriptor if found else NULL 192 + */ 193 + const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 194 + int desc_type) 195 + { 196 + int add_sen_len, add_len, desc_len, k; 197 + const u8 * descp; 198 + 199 + if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7]))) 200 + return NULL; 201 + if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73)) 202 + return NULL; 203 + add_sen_len = (add_sen_len < (sb_len - 8)) ? 204 + add_sen_len : (sb_len - 8); 205 + descp = &sense_buffer[8]; 206 + for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) { 207 + descp += desc_len; 208 + add_len = (k < (add_sen_len - 1)) ? descp[1]: -1; 209 + desc_len = add_len + 2; 210 + if (descp[0] == desc_type) 211 + return descp; 212 + if (add_len < 0) // short descriptor ?? 213 + break; 214 + } 215 + return NULL; 216 + } 217 + EXPORT_SYMBOL(scsi_sense_desc_find); 218 + 219 + /** 220 + * scsi_build_sense_buffer - build sense data in a buffer 221 + * @desc: Sense format (non zero == descriptor format, 222 + * 0 == fixed format) 223 + * @buf: Where to build sense data 224 + * @key: Sense key 225 + * @asc: Additional sense code 226 + * @ascq: Additional sense code qualifier 227 + * 228 + **/ 229 + void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq) 230 + { 231 + if (desc) { 232 + buf[0] = 0x72; /* descriptor, current */ 233 + buf[1] = key; 234 + buf[2] = asc; 235 + buf[3] = ascq; 236 + buf[7] = 0; 237 + } else { 238 + buf[0] = 0x70; /* fixed, current */ 239 + buf[2] = key; 240 + buf[7] = 0xa; 241 + buf[12] = asc; 242 + buf[13] = ascq; 243 + } 244 + } 245 + EXPORT_SYMBOL(scsi_build_sense_buffer); 246 + 247 + /** 248 + * scsi_set_sense_information - set the information field in a 249 + * formatted sense data buffer 250 + * @buf: Where to build sense data 251 + * @buf_len: buffer length 252 + * @info: 64-bit information value to be set 253 + * 254 + * Return value: 255 + * 0 on success or EINVAL for invalid sense buffer length 256 + **/ 257 + int scsi_set_sense_information(u8 *buf, int buf_len, u64 info) 258 + { 259 + if ((buf[0] & 0x7f) == 0x72) { 260 + u8 *ucp, len; 261 + 262 + len = buf[7]; 263 + ucp = (char *)scsi_sense_desc_find(buf, len + 8, 0); 264 + if (!ucp) { 265 + buf[7] = len + 0xc; 266 + ucp = buf + 8 + len; 267 + } 268 + 269 + if (buf_len < len + 0xc) 270 + /* Not enough room for info */ 271 + return -EINVAL; 272 + 273 + ucp[0] = 0; 274 + ucp[1] = 0xa; 275 + ucp[2] = 0x80; /* Valid bit */ 276 + ucp[3] = 0; 277 + put_unaligned_be64(info, &ucp[4]); 278 + } else if ((buf[0] & 0x7f) == 0x70) { 279 + buf[0] |= 0x80; 280 + put_unaligned_be64(info, &buf[3]); 281 + } 282 + 283 + return 0; 284 + } 285 + EXPORT_SYMBOL(scsi_set_sense_information);

+1 -67

drivers/scsi/scsi_error.c

··· 33 33 #include <scsi/scsi_device.h> 34 34 #include <scsi/scsi_driver.h> 35 35 #include <scsi/scsi_eh.h> 36 + #include <scsi/scsi_common.h> 36 37 #include <scsi/scsi_transport.h> 37 38 #include <scsi/scsi_host.h> 38 39 #include <scsi/scsi_ioctl.h> ··· 2426 2425 EXPORT_SYMBOL(scsi_command_normalize_sense); 2427 2426 2428 2427 /** 2429 - * scsi_sense_desc_find - search for a given descriptor type in descriptor sense data format. 2430 - * @sense_buffer: byte array of descriptor format sense data 2431 - * @sb_len: number of valid bytes in sense_buffer 2432 - * @desc_type: value of descriptor type to find 2433 - * (e.g. 0 -> information) 2434 - * 2435 - * Notes: 2436 - * only valid when sense data is in descriptor format 2437 - * 2438 - * Return value: 2439 - * pointer to start of (first) descriptor if found else NULL 2440 - */ 2441 - const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 2442 - int desc_type) 2443 - { 2444 - int add_sen_len, add_len, desc_len, k; 2445 - const u8 * descp; 2446 - 2447 - if ((sb_len < 8) || (0 == (add_sen_len = sense_buffer[7]))) 2448 - return NULL; 2449 - if ((sense_buffer[0] < 0x72) || (sense_buffer[0] > 0x73)) 2450 - return NULL; 2451 - add_sen_len = (add_sen_len < (sb_len - 8)) ? 2452 - add_sen_len : (sb_len - 8); 2453 - descp = &sense_buffer[8]; 2454 - for (desc_len = 0, k = 0; k < add_sen_len; k += desc_len) { 2455 - descp += desc_len; 2456 - add_len = (k < (add_sen_len - 1)) ? descp[1]: -1; 2457 - desc_len = add_len + 2; 2458 - if (descp[0] == desc_type) 2459 - return descp; 2460 - if (add_len < 0) // short descriptor ?? 2461 - break; 2462 - } 2463 - return NULL; 2464 - } 2465 - EXPORT_SYMBOL(scsi_sense_desc_find); 2466 - 2467 - /** 2468 2428 * scsi_get_sense_info_fld - get information field from sense data (either fixed or descriptor format) 2469 2429 * @sense_buffer: byte array of sense data 2470 2430 * @sb_len: number of valid bytes in sense_buffer ··· 2474 2512 } 2475 2513 } 2476 2514 EXPORT_SYMBOL(scsi_get_sense_info_fld); 2477 - 2478 - /** 2479 - * scsi_build_sense_buffer - build sense data in a buffer 2480 - * @desc: Sense format (non zero == descriptor format, 2481 - * 0 == fixed format) 2482 - * @buf: Where to build sense data 2483 - * @key: Sense key 2484 - * @asc: Additional sense code 2485 - * @ascq: Additional sense code qualifier 2486 - * 2487 - **/ 2488 - void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq) 2489 - { 2490 - if (desc) { 2491 - buf[0] = 0x72; /* descriptor, current */ 2492 - buf[1] = key; 2493 - buf[2] = asc; 2494 - buf[3] = ascq; 2495 - buf[7] = 0; 2496 - } else { 2497 - buf[0] = 0x70; /* fixed, current */ 2498 - buf[2] = key; 2499 - buf[7] = 0xa; 2500 - buf[12] = asc; 2501 - buf[13] = ascq; 2502 - } 2503 - } 2504 - EXPORT_SYMBOL(scsi_build_sense_buffer);

+37 -49

drivers/target/iscsi/iscsi_target.c

··· 269 269 } 270 270 271 271 bool iscsit_check_np_match( 272 - struct __kernel_sockaddr_storage *sockaddr, 272 + struct sockaddr_storage *sockaddr, 273 273 struct iscsi_np *np, 274 274 int network_transport) 275 275 { 276 276 struct sockaddr_in *sock_in, *sock_in_e; 277 277 struct sockaddr_in6 *sock_in6, *sock_in6_e; 278 278 bool ip_match = false; 279 - u16 port; 279 + u16 port, port_e; 280 280 281 281 if (sockaddr->ss_family == AF_INET6) { 282 282 sock_in6 = (struct sockaddr_in6 *)sockaddr; ··· 288 288 ip_match = true; 289 289 290 290 port = ntohs(sock_in6->sin6_port); 291 + port_e = ntohs(sock_in6_e->sin6_port); 291 292 } else { 292 293 sock_in = (struct sockaddr_in *)sockaddr; 293 294 sock_in_e = (struct sockaddr_in *)&np->np_sockaddr; ··· 297 296 ip_match = true; 298 297 299 298 port = ntohs(sock_in->sin_port); 299 + port_e = ntohs(sock_in_e->sin_port); 300 300 } 301 301 302 - if (ip_match && (np->np_port == port) && 302 + if (ip_match && (port_e == port) && 303 303 (np->np_network_transport == network_transport)) 304 304 return true; 305 305 ··· 311 309 * Called with mutex np_lock held 312 310 */ 313 311 static struct iscsi_np *iscsit_get_np( 314 - struct __kernel_sockaddr_storage *sockaddr, 312 + struct sockaddr_storage *sockaddr, 315 313 int network_transport) 316 314 { 317 315 struct iscsi_np *np; ··· 342 340 } 343 341 344 342 struct iscsi_np *iscsit_add_np( 345 - struct __kernel_sockaddr_storage *sockaddr, 346 - char *ip_str, 343 + struct sockaddr_storage *sockaddr, 347 344 int network_transport) 348 345 { 349 - struct sockaddr_in *sock_in; 350 - struct sockaddr_in6 *sock_in6; 351 346 struct iscsi_np *np; 352 347 int ret; 353 348 ··· 367 368 } 368 369 369 370 np->np_flags |= NPF_IP_NETWORK; 370 - if (sockaddr->ss_family == AF_INET6) { 371 - sock_in6 = (struct sockaddr_in6 *)sockaddr; 372 - snprintf(np->np_ip, IPV6_ADDRESS_SPACE, "%s", ip_str); 373 - np->np_port = ntohs(sock_in6->sin6_port); 374 - } else { 375 - sock_in = (struct sockaddr_in *)sockaddr; 376 - sprintf(np->np_ip, "%s", ip_str); 377 - np->np_port = ntohs(sock_in->sin_port); 378 - } 379 - 380 371 np->np_network_transport = network_transport; 381 372 spin_lock_init(&np->np_thread_lock); 382 373 init_completion(&np->np_restart_comp); ··· 400 411 list_add_tail(&np->np_list, &g_np_list); 401 412 mutex_unlock(&np_lock); 402 413 403 - pr_debug("CORE[0] - Added Network Portal: %s:%hu on %s\n", 404 - np->np_ip, np->np_port, np->np_transport->name); 414 + pr_debug("CORE[0] - Added Network Portal: %pISpc on %s\n", 415 + &np->np_sockaddr, np->np_transport->name); 405 416 406 417 return np; 407 418 } ··· 470 481 list_del(&np->np_list); 471 482 mutex_unlock(&np_lock); 472 483 473 - pr_debug("CORE[0] - Removed Network Portal: %s:%hu on %s\n", 474 - np->np_ip, np->np_port, np->np_transport->name); 484 + pr_debug("CORE[0] - Removed Network Portal: %pISpc on %s\n", 485 + &np->np_sockaddr, np->np_transport->name); 475 486 476 487 iscsit_put_transport(np->np_transport); 477 488 kfree(np); ··· 1198 1209 u8 *pad_bytes) 1199 1210 { 1200 1211 u32 data_crc; 1201 - u32 i; 1202 1212 struct scatterlist *sg; 1203 1213 unsigned int page_off; 1204 1214 ··· 1206 1218 sg = cmd->first_data_sg; 1207 1219 page_off = cmd->first_data_sg_off; 1208 1220 1209 - i = 0; 1210 1221 while (data_length) { 1211 - u32 cur_len = min_t(u32, data_length, (sg[i].length - page_off)); 1222 + u32 cur_len = min_t(u32, data_length, (sg->length - page_off)); 1212 1223 1213 - crypto_hash_update(hash, &sg[i], cur_len); 1224 + crypto_hash_update(hash, sg, cur_len); 1214 1225 1215 1226 data_length -= cur_len; 1216 1227 page_off = 0; 1217 - i++; 1228 + /* iscsit_map_iovec has already checked for invalid sg pointers */ 1229 + sg = sg_next(sg); 1218 1230 } 1219 1231 1220 1232 if (padding) { ··· 2544 2556 cmd->stat_sn = conn->stat_sn++; 2545 2557 hdr->statsn = cpu_to_be32(cmd->stat_sn); 2546 2558 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2547 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2559 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 2548 2560 hdr->async_event = ISCSI_ASYNC_MSG_DROPPING_CONNECTION; 2549 2561 hdr->param1 = cpu_to_be16(cmd->logout_cid); 2550 2562 hdr->param2 = cpu_to_be16(conn->sess->sess_ops->DefaultTime2Wait); ··· 2616 2628 hdr->statsn = cpu_to_be32(0xFFFFFFFF); 2617 2629 2618 2630 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2619 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2631 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 2620 2632 hdr->datasn = cpu_to_be32(datain->data_sn); 2621 2633 hdr->offset = cpu_to_be32(datain->offset); 2622 2634 ··· 2827 2839 2828 2840 iscsit_increment_maxcmdsn(cmd, conn->sess); 2829 2841 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2830 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2842 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 2831 2843 2832 2844 pr_debug("Built Logout Response ITT: 0x%08x StatSN:" 2833 2845 " 0x%08x Response: 0x%02x CID: %hu on CID: %hu\n", ··· 2890 2902 iscsit_increment_maxcmdsn(cmd, conn->sess); 2891 2903 2892 2904 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 2893 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 2905 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 2894 2906 2895 2907 pr_debug("Built NOPIN %s Response ITT: 0x%08x, TTT: 0x%08x," 2896 2908 " StatSN: 0x%08x, Length %u\n", (nopout_response) ? ··· 3037 3049 hdr->ttt = cpu_to_be32(r2t->targ_xfer_tag); 3038 3050 hdr->statsn = cpu_to_be32(conn->stat_sn); 3039 3051 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3040 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3052 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 3041 3053 hdr->r2tsn = cpu_to_be32(r2t->r2t_sn); 3042 3054 hdr->data_offset = cpu_to_be32(r2t->offset); 3043 3055 hdr->data_length = cpu_to_be32(r2t->xfer_len); ··· 3190 3202 3191 3203 iscsit_increment_maxcmdsn(cmd, conn->sess); 3192 3204 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3193 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3205 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 3194 3206 3195 3207 pr_debug("Built SCSI Response, ITT: 0x%08x, StatSN: 0x%08x," 3196 3208 " Response: 0x%02x, SAM Status: 0x%02x, CID: %hu\n", ··· 3309 3321 3310 3322 iscsit_increment_maxcmdsn(cmd, conn->sess); 3311 3323 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3312 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3324 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 3313 3325 3314 3326 pr_debug("Built Task Management Response ITT: 0x%08x," 3315 3327 " StatSN: 0x%08x, Response: 0x%02x, CID: %hu\n", ··· 3387 3399 int target_name_printed; 3388 3400 unsigned char buf[ISCSI_IQN_LEN+12]; /* iqn + "TargetName=" + \0 */ 3389 3401 unsigned char *text_in = cmd->text_in_ptr, *text_ptr = NULL; 3402 + bool active; 3390 3403 3391 3404 buffer_len = min(conn->conn_ops->MaxRecvDataSegmentLength, 3392 3405 SENDTARGETS_BUF_LIMIT); ··· 3441 3452 } 3442 3453 3443 3454 spin_lock(&tpg->tpg_state_lock); 3444 - if ((tpg->tpg_state == TPG_STATE_FREE) || 3445 - (tpg->tpg_state == TPG_STATE_INACTIVE)) { 3446 - spin_unlock(&tpg->tpg_state_lock); 3447 - continue; 3448 - } 3455 + active = (tpg->tpg_state == TPG_STATE_ACTIVE); 3449 3456 spin_unlock(&tpg->tpg_state_lock); 3457 + 3458 + if (!active && tpg->tpg_attrib.tpg_enabled_sendtargets) 3459 + continue; 3450 3460 3451 3461 spin_lock(&tpg->tpg_np_lock); 3452 3462 list_for_each_entry(tpg_np, &tpg->tpg_gnp_list, 3453 3463 tpg_np_list) { 3454 3464 struct iscsi_np *np = tpg_np->tpg_np; 3455 3465 bool inaddr_any = iscsit_check_inaddr_any(np); 3456 - char *fmt_str; 3466 + struct sockaddr_storage *sockaddr; 3457 3467 3458 3468 if (np->np_network_transport != network_transport) 3459 3469 continue; ··· 3480 3492 } 3481 3493 } 3482 3494 3483 - if (np->np_sockaddr.ss_family == AF_INET6) 3484 - fmt_str = "TargetAddress=[%s]:%hu,%hu"; 3495 + if (inaddr_any) 3496 + sockaddr = &conn->local_sockaddr; 3485 3497 else 3486 - fmt_str = "TargetAddress=%s:%hu,%hu"; 3498 + sockaddr = &np->np_sockaddr; 3487 3499 3488 - len = sprintf(buf, fmt_str, 3489 - inaddr_any ? conn->local_ip : np->np_ip, 3490 - np->np_port, 3491 - tpg->tpgt); 3500 + len = sprintf(buf, "TargetAddress=" 3501 + "%pISpc,%hu", 3502 + sockaddr, 3503 + tpg->tpgt); 3492 3504 len += 1; 3493 3505 3494 3506 if ((len + payload_len) > buffer_len) { ··· 3564 3576 */ 3565 3577 cmd->maxcmdsn_inc = 0; 3566 3578 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3567 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3579 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 3568 3580 3569 3581 pr_debug("Built Text Response: ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x," 3570 3582 " Length: %u, CID: %hu F: %d C: %d\n", cmd->init_task_tag, ··· 3642 3654 cmd->stat_sn = conn->stat_sn++; 3643 3655 hdr->statsn = cpu_to_be32(cmd->stat_sn); 3644 3656 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3645 - hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3657 + hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 3646 3658 3647 3659 } 3648 3660 EXPORT_SYMBOL(iscsit_build_reject);

+3 -3

drivers/target/iscsi/iscsi_target.h

··· 10 10 extern void iscsit_login_kref_put(struct kref *); 11 11 extern int iscsit_deaccess_np(struct iscsi_np *, struct iscsi_portal_group *, 12 12 struct iscsi_tpg_np *); 13 - extern bool iscsit_check_np_match(struct __kernel_sockaddr_storage *, 13 + extern bool iscsit_check_np_match(struct sockaddr_storage *, 14 14 struct iscsi_np *, int); 15 - extern struct iscsi_np *iscsit_add_np(struct __kernel_sockaddr_storage *, 16 - char *, int); 15 + extern struct iscsi_np *iscsit_add_np(struct sockaddr_storage *, 16 + int); 17 17 extern int iscsit_reset_np_thread(struct iscsi_np *, struct iscsi_tpg_np *, 18 18 struct iscsi_portal_group *, bool); 19 19 extern int iscsit_del_np(struct iscsi_np *);

+21 -13

drivers/target/iscsi/iscsi_target_configfs.c

··· 99 99 * Use existing np->np_sockaddr for SCTP network portal reference 100 100 */ 101 101 tpg_np_sctp = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr, 102 - np->np_ip, tpg_np, ISCSI_SCTP_TCP); 102 + tpg_np, ISCSI_SCTP_TCP); 103 103 if (!tpg_np_sctp || IS_ERR(tpg_np_sctp)) 104 104 goto out; 105 105 } else { ··· 177 177 } 178 178 179 179 tpg_np_iser = iscsit_tpg_add_network_portal(tpg, &np->np_sockaddr, 180 - np->np_ip, tpg_np, ISCSI_INFINIBAND); 180 + tpg_np, ISCSI_INFINIBAND); 181 181 if (IS_ERR(tpg_np_iser)) { 182 182 rc = PTR_ERR(tpg_np_iser); 183 183 goto out; ··· 220 220 struct iscsi_portal_group *tpg; 221 221 struct iscsi_tpg_np *tpg_np; 222 222 char *str, *str2, *ip_str, *port_str; 223 - struct __kernel_sockaddr_storage sockaddr; 223 + struct sockaddr_storage sockaddr; 224 224 struct sockaddr_in *sock_in; 225 225 struct sockaddr_in6 *sock_in6; 226 226 unsigned long port; ··· 235 235 memset(buf, 0, MAX_PORTAL_LEN + 1); 236 236 snprintf(buf, MAX_PORTAL_LEN + 1, "%s", name); 237 237 238 - memset(&sockaddr, 0, sizeof(struct __kernel_sockaddr_storage)); 238 + memset(&sockaddr, 0, sizeof(struct sockaddr_storage)); 239 239 240 240 str = strstr(buf, "["); 241 241 if (str) { ··· 248 248 return ERR_PTR(-EINVAL); 249 249 } 250 250 str++; /* Skip over leading "[" */ 251 - *str2 = '\0'; /* Terminate the IPv6 address */ 252 - str2++; /* Skip over the "]" */ 251 + *str2 = '\0'; /* Terminate the unbracketed IPv6 address */ 252 + str2++; /* Skip over the \0 */ 253 253 port_str = strstr(str2, ":"); 254 254 if (!port_str) { 255 255 pr_err("Unable to locate \":port\"" ··· 267 267 sock_in6 = (struct sockaddr_in6 *)&sockaddr; 268 268 sock_in6->sin6_family = AF_INET6; 269 269 sock_in6->sin6_port = htons((unsigned short)port); 270 - ret = in6_pton(str, IPV6_ADDRESS_SPACE, 270 + ret = in6_pton(str, -1, 271 271 (void *)&sock_in6->sin6_addr.in6_u, -1, &end); 272 272 if (ret <= 0) { 273 273 pr_err("in6_pton returned: %d\n", ret); ··· 316 316 * sys/kernel/config/iscsi/$IQN/$TPG/np/$IP:$PORT/ 317 317 * 318 318 */ 319 - tpg_np = iscsit_tpg_add_network_portal(tpg, &sockaddr, str, NULL, 319 + tpg_np = iscsit_tpg_add_network_portal(tpg, &sockaddr, NULL, 320 320 ISCSI_TCP); 321 321 if (IS_ERR(tpg_np)) { 322 322 iscsit_put_tpg(tpg); ··· 344 344 345 345 se_tpg = &tpg->tpg_se_tpg; 346 346 pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s TPGT: %hu" 347 - " PORTAL: %s:%hu\n", config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item), 348 - tpg->tpgt, tpg_np->tpg_np->np_ip, tpg_np->tpg_np->np_port); 347 + " PORTAL: %pISpc\n", config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item), 348 + tpg->tpgt, &tpg_np->tpg_np->np_sockaddr); 349 349 350 350 ret = iscsit_tpg_del_network_portal(tpg, tpg_np); 351 351 if (ret < 0) ··· 656 656 struct iscsi_conn *conn; 657 657 struct se_session *se_sess; 658 658 ssize_t rb = 0; 659 + u32 max_cmd_sn; 659 660 660 661 spin_lock_bh(&se_nacl->nacl_sess_lock); 661 662 se_sess = se_nacl->nacl_sess; ··· 704 703 " Values]-----------------------\n"); 705 704 rb += sprintf(page+rb, " CmdSN/WR : CmdSN/WC : ExpCmdSN" 706 705 " : MaxCmdSN : ITT : TTT\n"); 706 + max_cmd_sn = (u32) atomic_read(&sess->max_cmd_sn); 707 707 rb += sprintf(page+rb, " 0x%08x 0x%08x 0x%08x 0x%08x" 708 708 " 0x%08x 0x%08x\n", 709 709 sess->cmdsn_window, 710 - (sess->max_cmd_sn - sess->exp_cmd_sn) + 1, 711 - sess->exp_cmd_sn, sess->max_cmd_sn, 710 + (max_cmd_sn - sess->exp_cmd_sn) + 1, 711 + sess->exp_cmd_sn, max_cmd_sn, 712 712 sess->init_task_tag, sess->targ_xfer_tag); 713 713 rb += sprintf(page+rb, "----------------------[iSCSI" 714 714 " Connections]-------------------------\n"); ··· 753 751 break; 754 752 } 755 753 756 - rb += sprintf(page+rb, " Address %s %s", conn->login_ip, 754 + rb += sprintf(page+rb, " Address %pISc %s", &conn->login_sockaddr, 757 755 (conn->network_transport == ISCSI_TCP) ? 758 756 "TCP" : "SCTP"); 759 757 rb += sprintf(page+rb, " StatSN: 0x%08x\n", ··· 1012 1010 */ 1013 1011 DEF_TPG_ATTRIB(fabric_prot_type); 1014 1012 TPG_ATTR(fabric_prot_type, S_IRUGO | S_IWUSR); 1013 + /* 1014 + * Define iscsi_tpg_attrib_s_tpg_enabled_sendtargets 1015 + */ 1016 + DEF_TPG_ATTRIB(tpg_enabled_sendtargets); 1017 + TPG_ATTR(tpg_enabled_sendtargets, S_IRUGO | S_IWUSR); 1015 1018 1016 1019 static struct configfs_attribute *lio_target_tpg_attrib_attrs[] = { 1017 1020 &iscsi_tpg_attrib_authentication.attr, ··· 1031 1024 &iscsi_tpg_attrib_default_erl.attr, 1032 1025 &iscsi_tpg_attrib_t10_pi.attr, 1033 1026 &iscsi_tpg_attrib_fabric_prot_type.attr, 1027 + &iscsi_tpg_attrib_tpg_enabled_sendtargets.attr, 1034 1028 NULL, 1035 1029 }; 1036 1030

+5 -5

drivers/target/iscsi/iscsi_target_device.c

··· 47 47 * core_set_queue_depth_for_node(). 48 48 */ 49 49 sess->cmdsn_window = se_nacl->queue_depth; 50 - sess->max_cmd_sn = (sess->max_cmd_sn + se_nacl->queue_depth) - 1; 50 + atomic_add(se_nacl->queue_depth - 1, &sess->max_cmd_sn); 51 51 } 52 52 53 53 void iscsit_increment_maxcmdsn(struct iscsi_cmd *cmd, struct iscsi_session *sess) 54 54 { 55 + u32 max_cmd_sn; 56 + 55 57 if (cmd->immediate_cmd || cmd->maxcmdsn_inc) 56 58 return; 57 59 58 60 cmd->maxcmdsn_inc = 1; 59 61 60 - mutex_lock(&sess->cmdsn_mutex); 61 - sess->max_cmd_sn += 1; 62 - pr_debug("Updated MaxCmdSN to 0x%08x\n", sess->max_cmd_sn); 63 - mutex_unlock(&sess->cmdsn_mutex); 62 + max_cmd_sn = atomic_inc_return(&sess->max_cmd_sn); 63 + pr_debug("Updated MaxCmdSN to 0x%08x\n", max_cmd_sn); 64 64 } 65 65 EXPORT_SYMBOL(iscsit_increment_maxcmdsn);

+38 -40

drivers/target/iscsi/iscsi_target_login.c

··· 331 331 * The FFP CmdSN window values will be allocated from the TPG's 332 332 * Initiator Node's ACL once the login has been successfully completed. 333 333 */ 334 - sess->max_cmd_sn = be32_to_cpu(pdu->cmdsn); 334 + atomic_set(&sess->max_cmd_sn, be32_to_cpu(pdu->cmdsn)); 335 335 336 336 sess->sess_ops = kzalloc(sizeof(struct iscsi_sess_ops), GFP_KERNEL); 337 337 if (!sess->sess_ops) { ··· 729 729 stop_timer = 1; 730 730 } 731 731 732 - pr_debug("iSCSI Login successful on CID: %hu from %s to" 733 - " %s:%hu,%hu\n", conn->cid, conn->login_ip, 734 - conn->local_ip, conn->local_port, tpg->tpgt); 732 + pr_debug("iSCSI Login successful on CID: %hu from %pISpc to" 733 + " %pISpc,%hu\n", conn->cid, &conn->login_sockaddr, 734 + &conn->local_sockaddr, tpg->tpgt); 735 735 736 736 list_add_tail(&conn->conn_list, &sess->sess_conn_list); 737 737 atomic_inc(&sess->nconn); ··· 776 776 pr_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n"); 777 777 sess->session_state = TARG_SESS_STATE_LOGGED_IN; 778 778 779 - pr_debug("iSCSI Login successful on CID: %hu from %s to %s:%hu,%hu\n", 780 - conn->cid, conn->login_ip, conn->local_ip, conn->local_port, 779 + pr_debug("iSCSI Login successful on CID: %hu from %pISpc to %pISpc,%hu\n", 780 + conn->cid, &conn->login_sockaddr, &conn->local_sockaddr, 781 781 tpg->tpgt); 782 782 783 783 spin_lock_bh(&sess->conn_lock); ··· 823 823 struct iscsi_np *np = (struct iscsi_np *) data; 824 824 825 825 spin_lock_bh(&np->np_thread_lock); 826 - pr_err("iSCSI Login timeout on Network Portal %s:%hu\n", 827 - np->np_ip, np->np_port); 826 + pr_err("iSCSI Login timeout on Network Portal %pISpc\n", 827 + &np->np_sockaddr); 828 828 829 829 if (np->np_login_timer_flags & ISCSI_TF_STOP) { 830 830 spin_unlock_bh(&np->np_thread_lock); ··· 877 877 878 878 int iscsit_setup_np( 879 879 struct iscsi_np *np, 880 - struct __kernel_sockaddr_storage *sockaddr) 880 + struct sockaddr_storage *sockaddr) 881 881 { 882 882 struct socket *sock = NULL; 883 883 int backlog = ISCSIT_TCP_BACKLOG, ret, opt = 0, len; ··· 916 916 * in iscsi_target_configfs.c code.. 917 917 */ 918 918 memcpy(&np->np_sockaddr, sockaddr, 919 - sizeof(struct __kernel_sockaddr_storage)); 919 + sizeof(struct sockaddr_storage)); 920 920 921 921 if (sockaddr->ss_family == AF_INET6) 922 922 len = sizeof(struct sockaddr_in6); ··· 975 975 976 976 int iscsi_target_setup_login_socket( 977 977 struct iscsi_np *np, 978 - struct __kernel_sockaddr_storage *sockaddr) 978 + struct sockaddr_storage *sockaddr) 979 979 { 980 980 struct iscsit_transport *t; 981 981 int rc; ··· 1015 1015 rc = conn->sock->ops->getname(conn->sock, 1016 1016 (struct sockaddr *)&sock_in6, &err, 1); 1017 1017 if (!rc) { 1018 - if (!ipv6_addr_v4mapped(&sock_in6.sin6_addr)) 1019 - snprintf(conn->login_ip, sizeof(conn->login_ip), "[%pI6c]", 1020 - &sock_in6.sin6_addr.in6_u); 1021 - else 1022 - snprintf(conn->login_ip, sizeof(conn->login_ip), "%pI4", 1023 - &sock_in6.sin6_addr.s6_addr32[3]); 1024 - conn->login_port = ntohs(sock_in6.sin6_port); 1018 + if (!ipv6_addr_v4mapped(&sock_in6.sin6_addr)) { 1019 + memcpy(&conn->login_sockaddr, &sock_in6, sizeof(sock_in6)); 1020 + } else { 1021 + /* Pretend to be an ipv4 socket */ 1022 + sock_in.sin_family = AF_INET; 1023 + sock_in.sin_port = sock_in6.sin6_port; 1024 + memcpy(&sock_in.sin_addr, &sock_in6.sin6_addr.s6_addr32[3], 4); 1025 + memcpy(&conn->login_sockaddr, &sock_in, sizeof(sock_in)); 1026 + } 1025 1027 } 1026 1028 1027 1029 rc = conn->sock->ops->getname(conn->sock, 1028 1030 (struct sockaddr *)&sock_in6, &err, 0); 1029 1031 if (!rc) { 1030 - if (!ipv6_addr_v4mapped(&sock_in6.sin6_addr)) 1031 - snprintf(conn->local_ip, sizeof(conn->local_ip), "[%pI6c]", 1032 - &sock_in6.sin6_addr.in6_u); 1033 - else 1034 - snprintf(conn->local_ip, sizeof(conn->local_ip), "%pI4", 1035 - &sock_in6.sin6_addr.s6_addr32[3]); 1036 - conn->local_port = ntohs(sock_in6.sin6_port); 1032 + if (!ipv6_addr_v4mapped(&sock_in6.sin6_addr)) { 1033 + memcpy(&conn->local_sockaddr, &sock_in6, sizeof(sock_in6)); 1034 + } else { 1035 + /* Pretend to be an ipv4 socket */ 1036 + sock_in.sin_family = AF_INET; 1037 + sock_in.sin_port = sock_in6.sin6_port; 1038 + memcpy(&sock_in.sin_addr, &sock_in6.sin6_addr.s6_addr32[3], 4); 1039 + memcpy(&conn->local_sockaddr, &sock_in, sizeof(sock_in)); 1040 + } 1037 1041 } 1038 1042 } else { 1039 1043 memset(&sock_in, 0, sizeof(struct sockaddr_in)); 1040 1044 1041 1045 rc = conn->sock->ops->getname(conn->sock, 1042 1046 (struct sockaddr *)&sock_in, &err, 1); 1043 - if (!rc) { 1044 - sprintf(conn->login_ip, "%pI4", 1045 - &sock_in.sin_addr.s_addr); 1046 - conn->login_port = ntohs(sock_in.sin_port); 1047 - } 1047 + if (!rc) 1048 + memcpy(&conn->login_sockaddr, &sock_in, sizeof(sock_in)); 1048 1049 1049 1050 rc = conn->sock->ops->getname(conn->sock, 1050 1051 (struct sockaddr *)&sock_in, &err, 0); 1051 - if (!rc) { 1052 - sprintf(conn->local_ip, "%pI4", 1053 - &sock_in.sin_addr.s_addr); 1054 - conn->local_port = ntohs(sock_in.sin_port); 1055 - } 1052 + if (!rc) 1053 + memcpy(&conn->local_sockaddr, &sock_in, sizeof(sock_in)); 1056 1054 } 1057 1055 1058 1056 return 0; ··· 1300 1302 spin_lock_bh(&np->np_thread_lock); 1301 1303 if (np->np_thread_state != ISCSI_NP_THREAD_ACTIVE) { 1302 1304 spin_unlock_bh(&np->np_thread_lock); 1303 - pr_err("iSCSI Network Portal on %s:%hu currently not" 1304 - " active.\n", np->np_ip, np->np_port); 1305 + pr_err("iSCSI Network Portal on %pISpc currently not" 1306 + " active.\n", &np->np_sockaddr); 1305 1307 iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR, 1306 1308 ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE); 1307 1309 goto new_sess_out; ··· 1310 1312 1311 1313 conn->network_transport = np->np_network_transport; 1312 1314 1313 - pr_debug("Received iSCSI login request from %s on %s Network" 1314 - " Portal %s:%hu\n", conn->login_ip, np->np_transport->name, 1315 - conn->local_ip, conn->local_port); 1315 + pr_debug("Received iSCSI login request from %pISpc on %s Network" 1316 + " Portal %pISpc\n", &conn->login_sockaddr, np->np_transport->name, 1317 + &conn->local_sockaddr); 1316 1318 1317 1319 pr_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n"); 1318 1320 conn->conn_state = TARG_CONN_STATE_IN_LOGIN;

+2 -2

drivers/target/iscsi/iscsi_target_login.h

··· 5 5 extern int iscsi_check_for_session_reinstatement(struct iscsi_conn *); 6 6 extern int iscsi_login_post_auth_non_zero_tsih(struct iscsi_conn *, u16, u32); 7 7 extern int iscsit_setup_np(struct iscsi_np *, 8 - struct __kernel_sockaddr_storage *); 8 + struct sockaddr_storage *); 9 9 extern int iscsi_target_setup_login_socket(struct iscsi_np *, 10 - struct __kernel_sockaddr_storage *); 10 + struct sockaddr_storage *); 11 11 extern int iscsit_accept_np(struct iscsi_np *, struct iscsi_conn *); 12 12 extern int iscsit_get_login_rx(struct iscsi_conn *, struct iscsi_login *); 13 13 extern int iscsit_put_login_tx(struct iscsi_conn *, struct iscsi_login *, u32);

+1 -6

drivers/target/iscsi/iscsi_target_nego.c

··· 341 341 static int iscsi_target_do_tx_login_io(struct iscsi_conn *conn, struct iscsi_login *login) 342 342 { 343 343 u32 padding = 0; 344 - struct iscsi_session *sess = conn->sess; 345 344 struct iscsi_login_rsp *login_rsp; 346 345 347 346 login_rsp = (struct iscsi_login_rsp *) login->rsp; ··· 352 353 login_rsp->itt = login->init_task_tag; 353 354 login_rsp->statsn = cpu_to_be32(conn->stat_sn++); 354 355 login_rsp->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 355 - login_rsp->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 356 + login_rsp->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn)); 356 357 357 358 pr_debug("Sending Login Response, Flags: 0x%02x, ITT: 0x%08x," 358 359 " ExpCmdSN; 0x%08x, MaxCmdSN: 0x%08x, StatSN: 0x%08x, Length:" ··· 381 382 goto err; 382 383 383 384 login->rsp_length = 0; 384 - mutex_lock(&sess->cmdsn_mutex); 385 - login_rsp->exp_cmdsn = cpu_to_be32(sess->exp_cmd_sn); 386 - login_rsp->max_cmdsn = cpu_to_be32(sess->max_cmd_sn); 387 - mutex_unlock(&sess->cmdsn_mutex); 388 385 389 386 return 0; 390 387

+1 -1

drivers/target/iscsi/iscsi_target_stat.c

··· 430 430 int ret; 431 431 432 432 spin_lock(&lstat->lock); 433 - ret = snprintf(page, PAGE_SIZE, "%s\n", lstat->last_intr_fail_ip_addr); 433 + ret = snprintf(page, PAGE_SIZE, "%pISc\n", &lstat->last_intr_fail_sockaddr); 434 434 spin_unlock(&lstat->lock); 435 435 436 436 return ret;

+1 -1

drivers/target/iscsi/iscsi_target_tmr.c

··· 50 50 pr_err("Unable to locate RefTaskTag: 0x%08x on CID:" 51 51 " %hu.\n", hdr->rtt, conn->cid); 52 52 return (iscsi_sna_gte(be32_to_cpu(hdr->refcmdsn), conn->sess->exp_cmd_sn) && 53 - iscsi_sna_lte(be32_to_cpu(hdr->refcmdsn), conn->sess->max_cmd_sn)) ? 53 + iscsi_sna_lte(be32_to_cpu(hdr->refcmdsn), (u32) atomic_read(&conn->sess->max_cmd_sn))) ? 54 54 ISCSI_TMF_RSP_COMPLETE : ISCSI_TMF_RSP_NO_TASK; 55 55 } 56 56 if (ref_cmd->cmd_sn != be32_to_cpu(hdr->refcmdsn)) {

+28 -10

drivers/target/iscsi/iscsi_target_tpg.c

··· 226 226 a->default_erl = TA_DEFAULT_ERL; 227 227 a->t10_pi = TA_DEFAULT_T10_PI; 228 228 a->fabric_prot_type = TA_DEFAULT_FABRIC_PROT_TYPE; 229 + a->tpg_enabled_sendtargets = TA_DEFAULT_TPG_ENABLED_SENDTARGETS; 229 230 } 230 231 231 232 int iscsit_tpg_add_portal_group(struct iscsi_tiqn *tiqn, struct iscsi_portal_group *tpg) ··· 431 430 432 431 static bool iscsit_tpg_check_network_portal( 433 432 struct iscsi_tiqn *tiqn, 434 - struct __kernel_sockaddr_storage *sockaddr, 433 + struct sockaddr_storage *sockaddr, 435 434 int network_transport) 436 435 { 437 436 struct iscsi_portal_group *tpg; ··· 460 459 461 460 struct iscsi_tpg_np *iscsit_tpg_add_network_portal( 462 461 struct iscsi_portal_group *tpg, 463 - struct __kernel_sockaddr_storage *sockaddr, 464 - char *ip_str, 462 + struct sockaddr_storage *sockaddr, 465 463 struct iscsi_tpg_np *tpg_np_parent, 466 464 int network_transport) 467 465 { ··· 470 470 if (!tpg_np_parent) { 471 471 if (iscsit_tpg_check_network_portal(tpg->tpg_tiqn, sockaddr, 472 472 network_transport)) { 473 - pr_err("Network Portal: %s already exists on a" 474 - " different TPG on %s\n", ip_str, 473 + pr_err("Network Portal: %pISc already exists on a" 474 + " different TPG on %s\n", sockaddr, 475 475 tpg->tpg_tiqn->tiqn); 476 476 return ERR_PTR(-EEXIST); 477 477 } ··· 484 484 return ERR_PTR(-ENOMEM); 485 485 } 486 486 487 - np = iscsit_add_np(sockaddr, ip_str, network_transport); 487 + np = iscsit_add_np(sockaddr, network_transport); 488 488 if (IS_ERR(np)) { 489 489 kfree(tpg_np); 490 490 return ERR_CAST(np); ··· 514 514 spin_unlock(&tpg_np_parent->tpg_np_parent_lock); 515 515 } 516 516 517 - pr_debug("CORE[%s] - Added Network Portal: %s:%hu,%hu on %s\n", 518 - tpg->tpg_tiqn->tiqn, np->np_ip, np->np_port, tpg->tpgt, 517 + pr_debug("CORE[%s] - Added Network Portal: %pISpc,%hu on %s\n", 518 + tpg->tpg_tiqn->tiqn, &np->np_sockaddr, tpg->tpgt, 519 519 np->np_transport->name); 520 520 521 521 return tpg_np; ··· 528 528 { 529 529 iscsit_clear_tpg_np_login_thread(tpg_np, tpg, true); 530 530 531 - pr_debug("CORE[%s] - Removed Network Portal: %s:%hu,%hu on %s\n", 532 - tpg->tpg_tiqn->tiqn, np->np_ip, np->np_port, tpg->tpgt, 531 + pr_debug("CORE[%s] - Removed Network Portal: %pISpc,%hu on %s\n", 532 + tpg->tpg_tiqn->tiqn, &np->np_sockaddr, tpg->tpgt, 533 533 np->np_transport->name); 534 534 535 535 tpg_np->tpg_np = NULL; ··· 889 889 a->fabric_prot_type = prot_type; 890 890 pr_debug("iSCSI_TPG[%hu] - T10 Fabric Protection Type: %u\n", 891 891 tpg->tpgt, prot_type); 892 + 893 + return 0; 894 + } 895 + 896 + int iscsit_ta_tpg_enabled_sendtargets( 897 + struct iscsi_portal_group *tpg, 898 + u32 flag) 899 + { 900 + struct iscsi_tpg_attrib *a = &tpg->tpg_attrib; 901 + 902 + if ((flag != 0) && (flag != 1)) { 903 + pr_err("Illegal value %d\n", flag); 904 + return -EINVAL; 905 + } 906 + 907 + a->tpg_enabled_sendtargets = flag; 908 + pr_debug("iSCSI_TPG[%hu] - TPG enabled bit required for SendTargets:" 909 + " %s\n", tpg->tpgt, (a->tpg_enabled_sendtargets) ? "ON" : "OFF"); 892 910 893 911 return 0; 894 912 }

+2 -1

drivers/target/iscsi/iscsi_target_tpg.h

··· 22 22 extern void iscsit_tpg_del_external_nps(struct iscsi_tpg_np *); 23 23 extern struct iscsi_tpg_np *iscsit_tpg_locate_child_np(struct iscsi_tpg_np *, int); 24 24 extern struct iscsi_tpg_np *iscsit_tpg_add_network_portal(struct iscsi_portal_group *, 25 - struct __kernel_sockaddr_storage *, char *, struct iscsi_tpg_np *, 25 + struct sockaddr_storage *, struct iscsi_tpg_np *, 26 26 int); 27 27 extern int iscsit_tpg_del_network_portal(struct iscsi_portal_group *, 28 28 struct iscsi_tpg_np *); ··· 40 40 extern int iscsit_ta_default_erl(struct iscsi_portal_group *, u32); 41 41 extern int iscsit_ta_t10_pi(struct iscsi_portal_group *, u32); 42 42 extern int iscsit_ta_fabric_prot_type(struct iscsi_portal_group *, u32); 43 + extern int iscsit_ta_tpg_enabled_sendtargets(struct iscsi_portal_group *, u32); 43 44 44 45 #endif /* ISCSI_TARGET_TPG_H */

+33 -6

drivers/target/iscsi/iscsi_target_util.c

··· 233 233 234 234 static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cmdsn) 235 235 { 236 + u32 max_cmdsn; 236 237 int ret; 237 238 238 239 /* ··· 242 241 * or order CmdSNs due to multiple connection sessions and/or 243 242 * CRC failures. 244 243 */ 245 - if (iscsi_sna_gt(cmdsn, sess->max_cmd_sn)) { 244 + max_cmdsn = atomic_read(&sess->max_cmd_sn); 245 + if (iscsi_sna_gt(cmdsn, max_cmdsn)) { 246 246 pr_err("Received CmdSN: 0x%08x is greater than" 247 - " MaxCmdSN: 0x%08x, ignoring.\n", cmdsn, 248 - sess->max_cmd_sn); 247 + " MaxCmdSN: 0x%08x, ignoring.\n", cmdsn, max_cmdsn); 249 248 ret = CMDSN_MAXCMDSN_OVERRUN; 250 249 251 250 } else if (cmdsn == sess->exp_cmd_sn) { ··· 1372 1371 return iscsit_do_tx_data(conn, &c); 1373 1372 } 1374 1373 1374 + static bool sockaddr_equal(struct sockaddr_storage *x, struct sockaddr_storage *y) 1375 + { 1376 + switch (x->ss_family) { 1377 + case AF_INET: { 1378 + struct sockaddr_in *sinx = (struct sockaddr_in *)x; 1379 + struct sockaddr_in *siny = (struct sockaddr_in *)y; 1380 + if (sinx->sin_addr.s_addr != siny->sin_addr.s_addr) 1381 + return false; 1382 + if (sinx->sin_port != siny->sin_port) 1383 + return false; 1384 + break; 1385 + } 1386 + case AF_INET6: { 1387 + struct sockaddr_in6 *sinx = (struct sockaddr_in6 *)x; 1388 + struct sockaddr_in6 *siny = (struct sockaddr_in6 *)y; 1389 + if (!ipv6_addr_equal(&sinx->sin6_addr, &siny->sin6_addr)) 1390 + return false; 1391 + if (sinx->sin6_port != siny->sin6_port) 1392 + return false; 1393 + break; 1394 + } 1395 + default: 1396 + return false; 1397 + } 1398 + return true; 1399 + } 1400 + 1375 1401 void iscsit_collect_login_stats( 1376 1402 struct iscsi_conn *conn, 1377 1403 u8 status_class, ··· 1415 1387 ls = &tiqn->login_stats; 1416 1388 1417 1389 spin_lock(&ls->lock); 1418 - if (!strcmp(conn->login_ip, ls->last_intr_fail_ip_addr) && 1390 + if (sockaddr_equal(&conn->login_sockaddr, &ls->last_intr_fail_sockaddr) && 1419 1391 ((get_jiffies_64() - ls->last_fail_time) < 10)) { 1420 1392 /* We already have the failure info for this login */ 1421 1393 spin_unlock(&ls->lock); ··· 1455 1427 1456 1428 ls->last_intr_fail_ip_family = conn->login_family; 1457 1429 1458 - snprintf(ls->last_intr_fail_ip_addr, IPV6_ADDRESS_SPACE, 1459 - "%s", conn->login_ip); 1430 + ls->last_intr_fail_sockaddr = conn->login_sockaddr; 1460 1431 ls->last_fail_time = get_jiffies_64(); 1461 1432 } 1462 1433

+14 -8

drivers/target/loopback/tcm_loop.c

··· 526 526 static char *tcm_loop_get_endpoint_wwn(struct se_portal_group *se_tpg) 527 527 { 528 528 /* 529 - * Return the passed NAA identifier for the SAS Target Port 529 + * Return the passed NAA identifier for the Target Port 530 530 */ 531 531 return &tl_tpg(se_tpg)->tl_hba->tl_wwn_address[0]; 532 532 } ··· 845 845 transport_free_session(tl_nexus->se_sess); 846 846 goto out; 847 847 } 848 - /* Now, register the SAS I_T Nexus as active. */ 848 + /* Now, register the I_T Nexus as active. */ 849 849 transport_register_session(se_tpg, tl_nexus->se_sess->se_node_acl, 850 850 tl_nexus->se_sess, tl_nexus); 851 851 tl_tpg->tl_nexus = tl_nexus; ··· 884 884 " %s Initiator Port: %s\n", tcm_loop_dump_proto_id(tpg->tl_hba), 885 885 tl_nexus->se_sess->se_node_acl->initiatorname); 886 886 /* 887 - * Release the SCSI I_T Nexus to the emulated SAS Target Port 887 + * Release the SCSI I_T Nexus to the emulated Target Port 888 888 */ 889 889 transport_deregister_session(tl_nexus->se_sess); 890 890 tpg->tl_nexus = NULL; ··· 1034 1034 } 1035 1035 if (!strncmp(page, "offline", 7)) { 1036 1036 tl_tpg->tl_transport_status = TCM_TRANSPORT_OFFLINE; 1037 + if (tl_tpg->tl_nexus) { 1038 + struct se_session *tl_sess = tl_tpg->tl_nexus->se_sess; 1039 + 1040 + core_allocate_nexus_loss_ua(tl_sess->se_node_acl); 1041 + } 1037 1042 return count; 1038 1043 } 1039 1044 return -EINVAL; ··· 1082 1077 tl_tpg->tl_hba = tl_hba; 1083 1078 tl_tpg->tl_tpgt = tpgt; 1084 1079 /* 1085 - * Register the tl_tpg as a emulated SAS TCM Target Endpoint 1080 + * Register the tl_tpg as a emulated TCM Target Endpoint 1086 1081 */ 1087 1082 ret = core_tpg_register(wwn, &tl_tpg->tl_se_tpg, tl_hba->tl_proto_id); 1088 1083 if (ret < 0) ··· 1107 1102 tl_hba = tl_tpg->tl_hba; 1108 1103 tpgt = tl_tpg->tl_tpgt; 1109 1104 /* 1110 - * Release the I_T Nexus for the Virtual SAS link if present 1105 + * Release the I_T Nexus for the Virtual target link if present 1111 1106 */ 1112 1107 tcm_loop_drop_nexus(tl_tpg); 1113 1108 /* 1114 - * Deregister the tl_tpg as a emulated SAS TCM Target Endpoint 1109 + * Deregister the tl_tpg as a emulated TCM Target Endpoint 1115 1110 */ 1116 1111 core_tpg_deregister(se_tpg); 1117 1112 ··· 1204 1199 struct tcm_loop_hba, tl_hba_wwn); 1205 1200 1206 1201 pr_debug("TCM_Loop_ConfigFS: Deallocating emulated Target" 1207 - " SAS Address: %s at Linux/SCSI Host ID: %d\n", 1208 - tl_hba->tl_wwn_address, tl_hba->sh->host_no); 1202 + " %s Address: %s at Linux/SCSI Host ID: %d\n", 1203 + tcm_loop_dump_proto_id(tl_hba), tl_hba->tl_wwn_address, 1204 + tl_hba->sh->host_no); 1209 1205 /* 1210 1206 * Call device_unregister() on the original tl_hba->dev. 1211 1207 * tcm_loop_fabric_scsi.c:tcm_loop_release_adapter() will

+4 -7

drivers/target/target_core_device.c

··· 620 620 621 621 lacl->mapped_lun = mapped_lun; 622 622 lacl->se_lun_nacl = nacl; 623 - snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s", 624 - nacl->initiatorname); 625 623 626 624 return lacl; 627 625 } ··· 654 656 " InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(), 655 657 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, lacl->mapped_lun, 656 658 (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO", 657 - lacl->initiatorname); 659 + nacl->initiatorname); 658 660 /* 659 661 * Check to see if there are any existing persistent reservation APTPL 660 662 * pre-registrations that need to be enabled for this LUN ACL.. ··· 686 688 " InitiatorNode: %s Mapped LUN: %llu\n", 687 689 tpg->se_tpg_tfo->get_fabric_name(), 688 690 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 689 - lacl->initiatorname, lacl->mapped_lun); 691 + nacl->initiatorname, lacl->mapped_lun); 690 692 691 693 return 0; 692 694 } ··· 699 701 " Mapped LUN: %llu\n", tpg->se_tpg_tfo->get_fabric_name(), 700 702 tpg->se_tpg_tfo->tpg_get_tag(tpg), 701 703 tpg->se_tpg_tfo->get_fabric_name(), 702 - lacl->initiatorname, lacl->mapped_lun); 704 + lacl->se_lun_nacl->initiatorname, lacl->mapped_lun); 703 705 704 706 kfree(lacl); 705 707 } ··· 752 754 dev->dev_link_magic = SE_DEV_LINK_MAGIC; 753 755 dev->se_hba = hba; 754 756 dev->transport = hba->backend->ops; 755 - dev->prot_length = sizeof(struct se_dif_v1_tuple); 757 + dev->prot_length = sizeof(struct t10_pi_tuple); 756 758 dev->hba_index = hba->hba_index; 757 759 758 760 INIT_LIST_HEAD(&dev->dev_list); ··· 769 771 spin_lock_init(&dev->se_tmr_lock); 770 772 spin_lock_init(&dev->qf_cmd_lock); 771 773 sema_init(&dev->caw_sem, 1); 772 - atomic_set(&dev->dev_ordered_id, 0); 773 774 INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list); 774 775 spin_lock_init(&dev->t10_wwn.t10_vpd_lock); 775 776 INIT_LIST_HEAD(&dev->t10_pr.registration_list);

+1 -1

drivers/target/target_core_fabric_configfs.c

··· 203 203 pr_debug("%s_ConfigFS: Changed Initiator ACL: %s" 204 204 " Mapped LUN: %llu Write Protect bit to %s\n", 205 205 se_tpg->se_tpg_tfo->get_fabric_name(), 206 - lacl->initiatorname, lacl->mapped_lun, (op) ? "ON" : "OFF"); 206 + se_nacl->initiatorname, lacl->mapped_lun, (op) ? "ON" : "OFF"); 207 207 208 208 return count; 209 209

+5

drivers/target/target_core_hba.c

··· 184 184 kfree(hba); 185 185 return 0; 186 186 } 187 + 188 + bool target_sense_desc_format(struct se_device *dev) 189 + { 190 + return dev->transport->get_blocks(dev) > U32_MAX; 191 + }

+44 -5

drivers/target/target_core_sbc.c

··· 154 154 return 0; 155 155 } 156 156 157 + static sense_reason_t 158 + sbc_emulate_startstop(struct se_cmd *cmd) 159 + { 160 + unsigned char *cdb = cmd->t_task_cdb; 161 + 162 + /* 163 + * See sbc3r36 section 5.25 164 + * Immediate bit should be set since there is nothing to complete 165 + * POWER CONDITION MODIFIER 0h 166 + */ 167 + if (!(cdb[1] & 1) || cdb[2] || cdb[3]) 168 + return TCM_INVALID_CDB_FIELD; 169 + 170 + /* 171 + * See sbc3r36 section 5.25 172 + * POWER CONDITION 0h START_VALID - process START and LOEJ 173 + */ 174 + if (cdb[4] >> 4 & 0xf) 175 + return TCM_INVALID_CDB_FIELD; 176 + 177 + /* 178 + * See sbc3r36 section 5.25 179 + * LOEJ 0h - nothing to load or unload 180 + * START 1h - we are ready 181 + */ 182 + if (!(cdb[4] & 1) || (cdb[4] & 2) || (cdb[4] & 4)) 183 + return TCM_INVALID_CDB_FIELD; 184 + 185 + target_complete_cmd(cmd, SAM_STAT_GOOD); 186 + return 0; 187 + } 188 + 157 189 sector_t sbc_get_write_same_sectors(struct se_cmd *cmd) 158 190 { 159 191 u32 num_blocks; ··· 992 960 " than 1\n", sectors); 993 961 return TCM_INVALID_CDB_FIELD; 994 962 } 963 + if (sbc_check_dpofua(dev, cmd, cdb)) 964 + return TCM_INVALID_CDB_FIELD; 965 + 995 966 /* 996 967 * Double size because we have two buffers, note that 997 968 * zero is not an error.. ··· 1103 1068 */ 1104 1069 size = 0; 1105 1070 cmd->execute_cmd = sbc_emulate_noop; 1071 + break; 1072 + case START_STOP: 1073 + size = 0; 1074 + cmd->execute_cmd = sbc_emulate_startstop; 1106 1075 break; 1107 1076 default: 1108 1077 ret = spc_parse_cdb(cmd, &size); ··· 1230 1191 sbc_dif_generate(struct se_cmd *cmd) 1231 1192 { 1232 1193 struct se_device *dev = cmd->se_dev; 1233 - struct se_dif_v1_tuple *sdt; 1194 + struct t10_pi_tuple *sdt; 1234 1195 struct scatterlist *dsg = cmd->t_data_sg, *psg; 1235 1196 sector_t sector = cmd->t_task_lba; 1236 1197 void *daddr, *paddr; ··· 1242 1203 daddr = kmap_atomic(sg_page(dsg)) + dsg->offset; 1243 1204 1244 1205 for (j = 0; j < psg->length; 1245 - j += sizeof(struct se_dif_v1_tuple)) { 1206 + j += sizeof(*sdt)) { 1246 1207 __u16 crc; 1247 1208 unsigned int avail; 1248 1209 ··· 1295 1256 } 1296 1257 1297 1258 static sense_reason_t 1298 - sbc_dif_v1_verify(struct se_cmd *cmd, struct se_dif_v1_tuple *sdt, 1259 + sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt, 1299 1260 __u16 crc, sector_t sector, unsigned int ei_lba) 1300 1261 { 1301 1262 __be16 csum; ··· 1385 1346 unsigned int ei_lba, struct scatterlist *psg, int psg_off) 1386 1347 { 1387 1348 struct se_device *dev = cmd->se_dev; 1388 - struct se_dif_v1_tuple *sdt; 1349 + struct t10_pi_tuple *sdt; 1389 1350 struct scatterlist *dsg = cmd->t_data_sg; 1390 1351 sector_t sector = start; 1391 1352 void *daddr, *paddr; ··· 1400 1361 1401 1362 for (i = psg_off; i < psg->length && 1402 1363 sector < start + sectors; 1403 - i += sizeof(struct se_dif_v1_tuple)) { 1364 + i += sizeof(*sdt)) { 1404 1365 __u16 crc; 1405 1366 unsigned int avail; 1406 1367

+22 -33

drivers/target/target_core_spc.c

··· 484 484 spc_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf) 485 485 { 486 486 struct se_device *dev = cmd->se_dev; 487 - int have_tp = 0; 488 - int opt, min; 487 + u32 mtl = 0; 488 + int have_tp = 0, opt, min; 489 489 490 490 /* 491 491 * Following spc3r22 section 6.5.3 Block Limits VPD page, when ··· 516 516 517 517 /* 518 518 * Set MAXIMUM TRANSFER LENGTH 519 + * 520 + * XXX: Currently assumes single PAGE_SIZE per scatterlist for fabrics 521 + * enforcing maximum HW scatter-gather-list entry limit 519 522 */ 520 - put_unaligned_be32(dev->dev_attrib.hw_max_sectors, &buf[8]); 523 + if (cmd->se_tfo->max_data_sg_nents) { 524 + mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE) / 525 + dev->dev_attrib.block_size; 526 + } 527 + put_unaligned_be32(min_not_zero(mtl, dev->dev_attrib.hw_max_sectors), &buf[8]); 521 528 522 529 /* 523 530 * Set OPTIMAL TRANSFER LENGTH ··· 775 768 if (pc == 1) 776 769 goto out; 777 770 778 - p[2] = 2; 771 + /* GLTSD: No implicit save of log parameters */ 772 + p[2] = (1 << 1); 773 + if (target_sense_desc_format(dev)) 774 + /* D_SENSE: Descriptor format sense data for 64bit sectors */ 775 + p[2] |= (1 << 2); 776 + 779 777 /* 780 778 * From spc4r23, 7.4.7 Control mode page 781 779 * ··· 1163 1151 unsigned char *rbuf; 1164 1152 u8 ua_asc = 0, ua_ascq = 0; 1165 1153 unsigned char buf[SE_SENSE_BUF]; 1154 + bool desc_format = target_sense_desc_format(cmd->se_dev); 1166 1155 1167 1156 memset(buf, 0, SE_SENSE_BUF); 1168 1157 ··· 1177 1164 if (!rbuf) 1178 1165 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1179 1166 1180 - if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq)) { 1181 - /* 1182 - * CURRENT ERROR, UNIT ATTENTION 1183 - */ 1184 - buf[0] = 0x70; 1185 - buf[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION; 1186 - 1187 - /* 1188 - * The Additional Sense Code (ASC) from the UNIT ATTENTION 1189 - */ 1190 - buf[SPC_ASC_KEY_OFFSET] = ua_asc; 1191 - buf[SPC_ASCQ_KEY_OFFSET] = ua_ascq; 1192 - buf[7] = 0x0A; 1193 - } else { 1194 - /* 1195 - * CURRENT ERROR, NO SENSE 1196 - */ 1197 - buf[0] = 0x70; 1198 - buf[SPC_SENSE_KEY_OFFSET] = NO_SENSE; 1199 - 1200 - /* 1201 - * NO ADDITIONAL SENSE INFORMATION 1202 - */ 1203 - buf[SPC_ASC_KEY_OFFSET] = 0x00; 1204 - buf[7] = 0x0A; 1205 - } 1167 + if (!core_scsi3_ua_clear_for_request_sense(cmd, &ua_asc, &ua_ascq)) 1168 + scsi_build_sense_buffer(desc_format, buf, UNIT_ATTENTION, 1169 + ua_asc, ua_ascq); 1170 + else 1171 + scsi_build_sense_buffer(desc_format, buf, NO_SENSE, 0x0, 0x0); 1206 1172 1207 1173 memcpy(rbuf, buf, min_t(u32, sizeof(buf), cmd->data_length)); 1208 1174 transport_kunmap_data_sg(cmd); ··· 1410 1418 } 1411 1419 break; 1412 1420 default: 1413 - pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode" 1414 - " 0x%02x, sending CHECK_CONDITION.\n", 1415 - cmd->se_tfo->get_fabric_name(), cdb[0]); 1416 1421 return TCM_UNSUPPORTED_SCSI_OPCODE; 1417 1422 } 1418 1423

+17

drivers/target/target_core_tpg.c

··· 41 41 #include "target_core_internal.h" 42 42 #include "target_core_alua.h" 43 43 #include "target_core_pr.h" 44 + #include "target_core_ua.h" 44 45 45 46 extern struct se_device *g_lun0_dev; 46 47 ··· 83 82 return acl; 84 83 } 85 84 EXPORT_SYMBOL(core_tpg_get_initiator_node_acl); 85 + 86 + void core_allocate_nexus_loss_ua( 87 + struct se_node_acl *nacl) 88 + { 89 + struct se_dev_entry *deve; 90 + 91 + if (!nacl) 92 + return; 93 + 94 + rcu_read_lock(); 95 + hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) 96 + core_scsi3_ua_allocate(deve, 0x29, 97 + ASCQ_29H_NEXUS_LOSS_OCCURRED); 98 + rcu_read_unlock(); 99 + } 100 + EXPORT_SYMBOL(core_allocate_nexus_loss_ua); 86 101 87 102 /* core_tpg_add_node_to_devs(): 88 103 *

+223 -286

drivers/target/target_core_transport.c

··· 39 39 #include <net/sock.h> 40 40 #include <net/tcp.h> 41 41 #include <scsi/scsi_proto.h> 42 + #include <scsi/scsi_common.h> 42 43 43 44 #include <target/target_core_base.h> 44 45 #include <target/target_core_backend.h> ··· 1075 1074 } 1076 1075 EXPORT_SYMBOL(transport_set_vpd_ident); 1077 1076 1077 + static sense_reason_t 1078 + target_check_max_data_sg_nents(struct se_cmd *cmd, struct se_device *dev, 1079 + unsigned int size) 1080 + { 1081 + u32 mtl; 1082 + 1083 + if (!cmd->se_tfo->max_data_sg_nents) 1084 + return TCM_NO_SENSE; 1085 + /* 1086 + * Check if fabric enforced maximum SGL entries per I/O descriptor 1087 + * exceeds se_cmd->data_length. If true, set SCF_UNDERFLOW_BIT + 1088 + * residual_count and reduce original cmd->data_length to maximum 1089 + * length based on single PAGE_SIZE entry scatter-lists. 1090 + */ 1091 + mtl = (cmd->se_tfo->max_data_sg_nents * PAGE_SIZE); 1092 + if (cmd->data_length > mtl) { 1093 + /* 1094 + * If an existing CDB overflow is present, calculate new residual 1095 + * based on CDB size minus fabric maximum transfer length. 1096 + * 1097 + * If an existing CDB underflow is present, calculate new residual 1098 + * based on original cmd->data_length minus fabric maximum transfer 1099 + * length. 1100 + * 1101 + * Otherwise, set the underflow residual based on cmd->data_length 1102 + * minus fabric maximum transfer length. 1103 + */ 1104 + if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) { 1105 + cmd->residual_count = (size - mtl); 1106 + } else if (cmd->se_cmd_flags & SCF_UNDERFLOW_BIT) { 1107 + u32 orig_dl = size + cmd->residual_count; 1108 + cmd->residual_count = (orig_dl - mtl); 1109 + } else { 1110 + cmd->se_cmd_flags |= SCF_UNDERFLOW_BIT; 1111 + cmd->residual_count = (cmd->data_length - mtl); 1112 + } 1113 + cmd->data_length = mtl; 1114 + /* 1115 + * Reset sbc_check_prot() calculated protection payload 1116 + * length based upon the new smaller MTL. 1117 + */ 1118 + if (cmd->prot_length) { 1119 + u32 sectors = (mtl / dev->dev_attrib.block_size); 1120 + cmd->prot_length = dev->prot_length * sectors; 1121 + } 1122 + } 1123 + return TCM_NO_SENSE; 1124 + } 1125 + 1078 1126 sense_reason_t 1079 1127 target_cmd_size_check(struct se_cmd *cmd, unsigned int size) 1080 1128 { ··· 1137 1087 " 0x%02x\n", cmd->se_tfo->get_fabric_name(), 1138 1088 cmd->data_length, size, cmd->t_task_cdb[0]); 1139 1089 1140 - if (cmd->data_direction == DMA_TO_DEVICE) { 1141 - pr_err("Rejecting underflow/overflow" 1142 - " WRITE data\n"); 1090 + if (cmd->data_direction == DMA_TO_DEVICE && 1091 + cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) { 1092 + pr_err("Rejecting underflow/overflow WRITE data\n"); 1143 1093 return TCM_INVALID_CDB_FIELD; 1144 1094 } 1145 1095 /* ··· 1169 1119 } 1170 1120 } 1171 1121 1172 - return 0; 1122 + return target_check_max_data_sg_nents(cmd, dev, size); 1173 1123 1174 1124 } 1175 1125 ··· 1227 1177 " emulation is not supported\n"); 1228 1178 return TCM_INVALID_CDB_FIELD; 1229 1179 } 1230 - /* 1231 - * Used to determine when ORDERED commands should go from 1232 - * Dormant to Active status. 1233 - */ 1234 - cmd->se_ordered_id = atomic_inc_return(&dev->dev_ordered_id); 1235 - pr_debug("Allocated se_ordered_id: %u for Task Attr: 0x%02x on %s\n", 1236 - cmd->se_ordered_id, cmd->sam_task_attr, 1237 - dev->transport->name); 1180 + 1238 1181 return 0; 1239 1182 } 1240 1183 ··· 1289 1246 } 1290 1247 1291 1248 ret = dev->transport->parse_cdb(cmd); 1249 + if (ret == TCM_UNSUPPORTED_SCSI_OPCODE) 1250 + pr_warn_ratelimited("%s/%s: Unsupported SCSI Opcode 0x%02x, sending CHECK_CONDITION.\n", 1251 + cmd->se_tfo->get_fabric_name(), 1252 + cmd->se_sess->se_node_acl->initiatorname, 1253 + cmd->t_task_cdb[0]); 1292 1254 if (ret) 1293 1255 return ret; 1294 1256 ··· 1741 1693 1742 1694 check_stop: 1743 1695 transport_lun_remove_cmd(cmd); 1744 - if (!transport_cmd_check_stop_to_fabric(cmd)) 1745 - ; 1696 + transport_cmd_check_stop_to_fabric(cmd); 1746 1697 return; 1747 1698 1748 1699 queue_full: ··· 1814 1767 */ 1815 1768 switch (cmd->sam_task_attr) { 1816 1769 case TCM_HEAD_TAG: 1817 - pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x, " 1818 - "se_ordered_id: %u\n", 1819 - cmd->t_task_cdb[0], cmd->se_ordered_id); 1770 + pr_debug("Added HEAD_OF_QUEUE for CDB: 0x%02x\n", 1771 + cmd->t_task_cdb[0]); 1820 1772 return false; 1821 1773 case TCM_ORDERED_TAG: 1822 1774 atomic_inc_mb(&dev->dev_ordered_sync); 1823 1775 1824 - pr_debug("Added ORDERED for CDB: 0x%02x to ordered list, " 1825 - " se_ordered_id: %u\n", 1826 - cmd->t_task_cdb[0], cmd->se_ordered_id); 1776 + pr_debug("Added ORDERED for CDB: 0x%02x to ordered list\n", 1777 + cmd->t_task_cdb[0]); 1827 1778 1828 1779 /* 1829 1780 * Execute an ORDERED command if no other older commands ··· 1845 1800 list_add_tail(&cmd->se_delayed_node, &dev->delayed_cmd_list); 1846 1801 spin_unlock(&dev->delayed_cmd_lock); 1847 1802 1848 - pr_debug("Added CDB: 0x%02x Task Attr: 0x%02x to" 1849 - " delayed CMD list, se_ordered_id: %u\n", 1850 - cmd->t_task_cdb[0], cmd->sam_task_attr, 1851 - cmd->se_ordered_id); 1803 + pr_debug("Added CDB: 0x%02x Task Attr: 0x%02x to delayed CMD listn", 1804 + cmd->t_task_cdb[0], cmd->sam_task_attr); 1852 1805 return true; 1853 1806 } 1854 1807 ··· 1931 1888 if (cmd->sam_task_attr == TCM_SIMPLE_TAG) { 1932 1889 atomic_dec_mb(&dev->simple_cmds); 1933 1890 dev->dev_cur_ordered_id++; 1934 - pr_debug("Incremented dev->dev_cur_ordered_id: %u for" 1935 - " SIMPLE: %u\n", dev->dev_cur_ordered_id, 1936 - cmd->se_ordered_id); 1891 + pr_debug("Incremented dev->dev_cur_ordered_id: %u for SIMPLE\n", 1892 + dev->dev_cur_ordered_id); 1937 1893 } else if (cmd->sam_task_attr == TCM_HEAD_TAG) { 1938 1894 dev->dev_cur_ordered_id++; 1939 - pr_debug("Incremented dev_cur_ordered_id: %u for" 1940 - " HEAD_OF_QUEUE: %u\n", dev->dev_cur_ordered_id, 1941 - cmd->se_ordered_id); 1895 + pr_debug("Incremented dev_cur_ordered_id: %u for HEAD_OF_QUEUE\n", 1896 + dev->dev_cur_ordered_id); 1942 1897 } else if (cmd->sam_task_attr == TCM_ORDERED_TAG) { 1943 1898 atomic_dec_mb(&dev->dev_ordered_sync); 1944 1899 1945 1900 dev->dev_cur_ordered_id++; 1946 - pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED:" 1947 - " %u\n", dev->dev_cur_ordered_id, cmd->se_ordered_id); 1901 + pr_debug("Incremented dev_cur_ordered_id: %u for ORDERED\n", 1902 + dev->dev_cur_ordered_id); 1948 1903 } 1949 1904 1950 1905 target_restart_delayed_cmds(dev); ··· 2656 2615 } 2657 2616 EXPORT_SYMBOL(transport_wait_for_tasks); 2658 2617 2659 - static int transport_get_sense_codes( 2660 - struct se_cmd *cmd, 2661 - u8 *asc, 2662 - u8 *ascq) 2618 + struct sense_info { 2619 + u8 key; 2620 + u8 asc; 2621 + u8 ascq; 2622 + bool add_sector_info; 2623 + }; 2624 + 2625 + static const struct sense_info sense_info_table[] = { 2626 + [TCM_NO_SENSE] = { 2627 + .key = NOT_READY 2628 + }, 2629 + [TCM_NON_EXISTENT_LUN] = { 2630 + .key = ILLEGAL_REQUEST, 2631 + .asc = 0x25 /* LOGICAL UNIT NOT SUPPORTED */ 2632 + }, 2633 + [TCM_UNSUPPORTED_SCSI_OPCODE] = { 2634 + .key = ILLEGAL_REQUEST, 2635 + .asc = 0x20, /* INVALID COMMAND OPERATION CODE */ 2636 + }, 2637 + [TCM_SECTOR_COUNT_TOO_MANY] = { 2638 + .key = ILLEGAL_REQUEST, 2639 + .asc = 0x20, /* INVALID COMMAND OPERATION CODE */ 2640 + }, 2641 + [TCM_UNKNOWN_MODE_PAGE] = { 2642 + .key = ILLEGAL_REQUEST, 2643 + .asc = 0x24, /* INVALID FIELD IN CDB */ 2644 + }, 2645 + [TCM_CHECK_CONDITION_ABORT_CMD] = { 2646 + .key = ABORTED_COMMAND, 2647 + .asc = 0x29, /* BUS DEVICE RESET FUNCTION OCCURRED */ 2648 + .ascq = 0x03, 2649 + }, 2650 + [TCM_INCORRECT_AMOUNT_OF_DATA] = { 2651 + .key = ABORTED_COMMAND, 2652 + .asc = 0x0c, /* WRITE ERROR */ 2653 + .ascq = 0x0d, /* NOT ENOUGH UNSOLICITED DATA */ 2654 + }, 2655 + [TCM_INVALID_CDB_FIELD] = { 2656 + .key = ILLEGAL_REQUEST, 2657 + .asc = 0x24, /* INVALID FIELD IN CDB */ 2658 + }, 2659 + [TCM_INVALID_PARAMETER_LIST] = { 2660 + .key = ILLEGAL_REQUEST, 2661 + .asc = 0x26, /* INVALID FIELD IN PARAMETER LIST */ 2662 + }, 2663 + [TCM_PARAMETER_LIST_LENGTH_ERROR] = { 2664 + .key = ILLEGAL_REQUEST, 2665 + .asc = 0x1a, /* PARAMETER LIST LENGTH ERROR */ 2666 + }, 2667 + [TCM_UNEXPECTED_UNSOLICITED_DATA] = { 2668 + .key = ILLEGAL_REQUEST, 2669 + .asc = 0x0c, /* WRITE ERROR */ 2670 + .ascq = 0x0c, /* UNEXPECTED_UNSOLICITED_DATA */ 2671 + }, 2672 + [TCM_SERVICE_CRC_ERROR] = { 2673 + .key = ABORTED_COMMAND, 2674 + .asc = 0x47, /* PROTOCOL SERVICE CRC ERROR */ 2675 + .ascq = 0x05, /* N/A */ 2676 + }, 2677 + [TCM_SNACK_REJECTED] = { 2678 + .key = ABORTED_COMMAND, 2679 + .asc = 0x11, /* READ ERROR */ 2680 + .ascq = 0x13, /* FAILED RETRANSMISSION REQUEST */ 2681 + }, 2682 + [TCM_WRITE_PROTECTED] = { 2683 + .key = DATA_PROTECT, 2684 + .asc = 0x27, /* WRITE PROTECTED */ 2685 + }, 2686 + [TCM_ADDRESS_OUT_OF_RANGE] = { 2687 + .key = ILLEGAL_REQUEST, 2688 + .asc = 0x21, /* LOGICAL BLOCK ADDRESS OUT OF RANGE */ 2689 + }, 2690 + [TCM_CHECK_CONDITION_UNIT_ATTENTION] = { 2691 + .key = UNIT_ATTENTION, 2692 + }, 2693 + [TCM_CHECK_CONDITION_NOT_READY] = { 2694 + .key = NOT_READY, 2695 + }, 2696 + [TCM_MISCOMPARE_VERIFY] = { 2697 + .key = MISCOMPARE, 2698 + .asc = 0x1d, /* MISCOMPARE DURING VERIFY OPERATION */ 2699 + .ascq = 0x00, 2700 + }, 2701 + [TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED] = { 2702 + .key = ABORTED_COMMAND, 2703 + .asc = 0x10, 2704 + .ascq = 0x01, /* LOGICAL BLOCK GUARD CHECK FAILED */ 2705 + .add_sector_info = true, 2706 + }, 2707 + [TCM_LOGICAL_BLOCK_APP_TAG_CHECK_FAILED] = { 2708 + .key = ABORTED_COMMAND, 2709 + .asc = 0x10, 2710 + .ascq = 0x02, /* LOGICAL BLOCK APPLICATION TAG CHECK FAILED */ 2711 + .add_sector_info = true, 2712 + }, 2713 + [TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED] = { 2714 + .key = ABORTED_COMMAND, 2715 + .asc = 0x10, 2716 + .ascq = 0x03, /* LOGICAL BLOCK REFERENCE TAG CHECK FAILED */ 2717 + .add_sector_info = true, 2718 + }, 2719 + [TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE] = { 2720 + /* 2721 + * Returning ILLEGAL REQUEST would cause immediate IO errors on 2722 + * Solaris initiators. Returning NOT READY instead means the 2723 + * operations will be retried a finite number of times and we 2724 + * can survive intermittent errors. 2725 + */ 2726 + .key = NOT_READY, 2727 + .asc = 0x08, /* LOGICAL UNIT COMMUNICATION FAILURE */ 2728 + }, 2729 + }; 2730 + 2731 + static int translate_sense_reason(struct se_cmd *cmd, sense_reason_t reason) 2663 2732 { 2664 - *asc = cmd->scsi_asc; 2665 - *ascq = cmd->scsi_ascq; 2733 + const struct sense_info *si; 2734 + u8 *buffer = cmd->sense_buffer; 2735 + int r = (__force int)reason; 2736 + u8 asc, ascq; 2737 + bool desc_format = target_sense_desc_format(cmd->se_dev); 2738 + 2739 + if (r < ARRAY_SIZE(sense_info_table) && sense_info_table[r].key) 2740 + si = &sense_info_table[r]; 2741 + else 2742 + si = &sense_info_table[(__force int) 2743 + TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE]; 2744 + 2745 + if (reason == TCM_CHECK_CONDITION_UNIT_ATTENTION) { 2746 + core_scsi3_ua_for_check_condition(cmd, &asc, &ascq); 2747 + WARN_ON_ONCE(asc == 0); 2748 + } else if (si->asc == 0) { 2749 + WARN_ON_ONCE(cmd->scsi_asc == 0); 2750 + asc = cmd->scsi_asc; 2751 + ascq = cmd->scsi_ascq; 2752 + } else { 2753 + asc = si->asc; 2754 + ascq = si->ascq; 2755 + } 2756 + 2757 + scsi_build_sense_buffer(desc_format, buffer, si->key, asc, ascq); 2758 + if (si->add_sector_info) 2759 + return scsi_set_sense_information(buffer, 2760 + cmd->scsi_sense_length, 2761 + cmd->bad_sector); 2666 2762 2667 2763 return 0; 2668 - } 2669 - 2670 - static 2671 - void transport_err_sector_info(unsigned char *buffer, sector_t bad_sector) 2672 - { 2673 - /* Place failed LBA in sense data information descriptor 0. */ 2674 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 0xc; 2675 - buffer[SPC_DESC_TYPE_OFFSET] = 0; /* Information */ 2676 - buffer[SPC_ADDITIONAL_DESC_LEN_OFFSET] = 0xa; 2677 - buffer[SPC_VALIDITY_OFFSET] = 0x80; 2678 - 2679 - /* Descriptor Information: failing sector */ 2680 - put_unaligned_be64(bad_sector, &buffer[12]); 2681 2764 } 2682 2765 2683 2766 int 2684 2767 transport_send_check_condition_and_sense(struct se_cmd *cmd, 2685 2768 sense_reason_t reason, int from_transport) 2686 2769 { 2687 - unsigned char *buffer = cmd->sense_buffer; 2688 2770 unsigned long flags; 2689 - u8 asc = 0, ascq = 0; 2690 2771 2691 2772 spin_lock_irqsave(&cmd->t_state_lock, flags); 2692 2773 if (cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) { ··· 2818 2655 cmd->se_cmd_flags |= SCF_SENT_CHECK_CONDITION; 2819 2656 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2820 2657 2821 - if (!reason && from_transport) 2822 - goto after_reason; 2658 + if (!from_transport) { 2659 + int rc; 2823 2660 2824 - if (!from_transport) 2825 2661 cmd->se_cmd_flags |= SCF_EMULATED_TASK_SENSE; 2826 - 2827 - /* 2828 - * Actual SENSE DATA, see SPC-3 7.23.2 SPC_SENSE_KEY_OFFSET uses 2829 - * SENSE KEY values from include/scsi/scsi.h 2830 - */ 2831 - switch (reason) { 2832 - case TCM_NO_SENSE: 2833 - /* CURRENT ERROR */ 2834 - buffer[0] = 0x70; 2835 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2836 - /* Not Ready */ 2837 - buffer[SPC_SENSE_KEY_OFFSET] = NOT_READY; 2838 - /* NO ADDITIONAL SENSE INFORMATION */ 2839 - buffer[SPC_ASC_KEY_OFFSET] = 0; 2840 - buffer[SPC_ASCQ_KEY_OFFSET] = 0; 2841 - break; 2842 - case TCM_NON_EXISTENT_LUN: 2843 - /* CURRENT ERROR */ 2844 - buffer[0] = 0x70; 2845 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2846 - /* ILLEGAL REQUEST */ 2847 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2848 - /* LOGICAL UNIT NOT SUPPORTED */ 2849 - buffer[SPC_ASC_KEY_OFFSET] = 0x25; 2850 - break; 2851 - case TCM_UNSUPPORTED_SCSI_OPCODE: 2852 - case TCM_SECTOR_COUNT_TOO_MANY: 2853 - /* CURRENT ERROR */ 2854 - buffer[0] = 0x70; 2855 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2856 - /* ILLEGAL REQUEST */ 2857 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2858 - /* INVALID COMMAND OPERATION CODE */ 2859 - buffer[SPC_ASC_KEY_OFFSET] = 0x20; 2860 - break; 2861 - case TCM_UNKNOWN_MODE_PAGE: 2862 - /* CURRENT ERROR */ 2863 - buffer[0] = 0x70; 2864 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2865 - /* ILLEGAL REQUEST */ 2866 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2867 - /* INVALID FIELD IN CDB */ 2868 - buffer[SPC_ASC_KEY_OFFSET] = 0x24; 2869 - break; 2870 - case TCM_CHECK_CONDITION_ABORT_CMD: 2871 - /* CURRENT ERROR */ 2872 - buffer[0] = 0x70; 2873 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2874 - /* ABORTED COMMAND */ 2875 - buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2876 - /* BUS DEVICE RESET FUNCTION OCCURRED */ 2877 - buffer[SPC_ASC_KEY_OFFSET] = 0x29; 2878 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x03; 2879 - break; 2880 - case TCM_INCORRECT_AMOUNT_OF_DATA: 2881 - /* CURRENT ERROR */ 2882 - buffer[0] = 0x70; 2883 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2884 - /* ABORTED COMMAND */ 2885 - buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2886 - /* WRITE ERROR */ 2887 - buffer[SPC_ASC_KEY_OFFSET] = 0x0c; 2888 - /* NOT ENOUGH UNSOLICITED DATA */ 2889 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x0d; 2890 - break; 2891 - case TCM_INVALID_CDB_FIELD: 2892 - /* CURRENT ERROR */ 2893 - buffer[0] = 0x70; 2894 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2895 - /* ILLEGAL REQUEST */ 2896 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2897 - /* INVALID FIELD IN CDB */ 2898 - buffer[SPC_ASC_KEY_OFFSET] = 0x24; 2899 - break; 2900 - case TCM_INVALID_PARAMETER_LIST: 2901 - /* CURRENT ERROR */ 2902 - buffer[0] = 0x70; 2903 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2904 - /* ILLEGAL REQUEST */ 2905 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2906 - /* INVALID FIELD IN PARAMETER LIST */ 2907 - buffer[SPC_ASC_KEY_OFFSET] = 0x26; 2908 - break; 2909 - case TCM_PARAMETER_LIST_LENGTH_ERROR: 2910 - /* CURRENT ERROR */ 2911 - buffer[0] = 0x70; 2912 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2913 - /* ILLEGAL REQUEST */ 2914 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2915 - /* PARAMETER LIST LENGTH ERROR */ 2916 - buffer[SPC_ASC_KEY_OFFSET] = 0x1a; 2917 - break; 2918 - case TCM_UNEXPECTED_UNSOLICITED_DATA: 2919 - /* CURRENT ERROR */ 2920 - buffer[0] = 0x70; 2921 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2922 - /* ABORTED COMMAND */ 2923 - buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2924 - /* WRITE ERROR */ 2925 - buffer[SPC_ASC_KEY_OFFSET] = 0x0c; 2926 - /* UNEXPECTED_UNSOLICITED_DATA */ 2927 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x0c; 2928 - break; 2929 - case TCM_SERVICE_CRC_ERROR: 2930 - /* CURRENT ERROR */ 2931 - buffer[0] = 0x70; 2932 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2933 - /* ABORTED COMMAND */ 2934 - buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2935 - /* PROTOCOL SERVICE CRC ERROR */ 2936 - buffer[SPC_ASC_KEY_OFFSET] = 0x47; 2937 - /* N/A */ 2938 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x05; 2939 - break; 2940 - case TCM_SNACK_REJECTED: 2941 - /* CURRENT ERROR */ 2942 - buffer[0] = 0x70; 2943 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2944 - /* ABORTED COMMAND */ 2945 - buffer[SPC_SENSE_KEY_OFFSET] = ABORTED_COMMAND; 2946 - /* READ ERROR */ 2947 - buffer[SPC_ASC_KEY_OFFSET] = 0x11; 2948 - /* FAILED RETRANSMISSION REQUEST */ 2949 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x13; 2950 - break; 2951 - case TCM_WRITE_PROTECTED: 2952 - /* CURRENT ERROR */ 2953 - buffer[0] = 0x70; 2954 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2955 - /* DATA PROTECT */ 2956 - buffer[SPC_SENSE_KEY_OFFSET] = DATA_PROTECT; 2957 - /* WRITE PROTECTED */ 2958 - buffer[SPC_ASC_KEY_OFFSET] = 0x27; 2959 - break; 2960 - case TCM_ADDRESS_OUT_OF_RANGE: 2961 - /* CURRENT ERROR */ 2962 - buffer[0] = 0x70; 2963 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2964 - /* ILLEGAL REQUEST */ 2965 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 2966 - /* LOGICAL BLOCK ADDRESS OUT OF RANGE */ 2967 - buffer[SPC_ASC_KEY_OFFSET] = 0x21; 2968 - break; 2969 - case TCM_CHECK_CONDITION_UNIT_ATTENTION: 2970 - /* CURRENT ERROR */ 2971 - buffer[0] = 0x70; 2972 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2973 - /* UNIT ATTENTION */ 2974 - buffer[SPC_SENSE_KEY_OFFSET] = UNIT_ATTENTION; 2975 - core_scsi3_ua_for_check_condition(cmd, &asc, &ascq); 2976 - buffer[SPC_ASC_KEY_OFFSET] = asc; 2977 - buffer[SPC_ASCQ_KEY_OFFSET] = ascq; 2978 - break; 2979 - case TCM_CHECK_CONDITION_NOT_READY: 2980 - /* CURRENT ERROR */ 2981 - buffer[0] = 0x70; 2982 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2983 - /* Not Ready */ 2984 - buffer[SPC_SENSE_KEY_OFFSET] = NOT_READY; 2985 - transport_get_sense_codes(cmd, &asc, &ascq); 2986 - buffer[SPC_ASC_KEY_OFFSET] = asc; 2987 - buffer[SPC_ASCQ_KEY_OFFSET] = ascq; 2988 - break; 2989 - case TCM_MISCOMPARE_VERIFY: 2990 - /* CURRENT ERROR */ 2991 - buffer[0] = 0x70; 2992 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 2993 - buffer[SPC_SENSE_KEY_OFFSET] = MISCOMPARE; 2994 - /* MISCOMPARE DURING VERIFY OPERATION */ 2995 - buffer[SPC_ASC_KEY_OFFSET] = 0x1d; 2996 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x00; 2997 - break; 2998 - case TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED: 2999 - /* CURRENT ERROR */ 3000 - buffer[0] = 0x70; 3001 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3002 - /* ILLEGAL REQUEST */ 3003 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 3004 - /* LOGICAL BLOCK GUARD CHECK FAILED */ 3005 - buffer[SPC_ASC_KEY_OFFSET] = 0x10; 3006 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x01; 3007 - transport_err_sector_info(buffer, cmd->bad_sector); 3008 - break; 3009 - case TCM_LOGICAL_BLOCK_APP_TAG_CHECK_FAILED: 3010 - /* CURRENT ERROR */ 3011 - buffer[0] = 0x70; 3012 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3013 - /* ILLEGAL REQUEST */ 3014 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 3015 - /* LOGICAL BLOCK APPLICATION TAG CHECK FAILED */ 3016 - buffer[SPC_ASC_KEY_OFFSET] = 0x10; 3017 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x02; 3018 - transport_err_sector_info(buffer, cmd->bad_sector); 3019 - break; 3020 - case TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED: 3021 - /* CURRENT ERROR */ 3022 - buffer[0] = 0x70; 3023 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3024 - /* ILLEGAL REQUEST */ 3025 - buffer[SPC_SENSE_KEY_OFFSET] = ILLEGAL_REQUEST; 3026 - /* LOGICAL BLOCK REFERENCE TAG CHECK FAILED */ 3027 - buffer[SPC_ASC_KEY_OFFSET] = 0x10; 3028 - buffer[SPC_ASCQ_KEY_OFFSET] = 0x03; 3029 - transport_err_sector_info(buffer, cmd->bad_sector); 3030 - break; 3031 - case TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE: 3032 - default: 3033 - /* CURRENT ERROR */ 3034 - buffer[0] = 0x70; 3035 - buffer[SPC_ADD_SENSE_LEN_OFFSET] = 10; 3036 - /* 3037 - * Returning ILLEGAL REQUEST would cause immediate IO errors on 3038 - * Solaris initiators. Returning NOT READY instead means the 3039 - * operations will be retried a finite number of times and we 3040 - * can survive intermittent errors. 3041 - */ 3042 - buffer[SPC_SENSE_KEY_OFFSET] = NOT_READY; 3043 - /* LOGICAL UNIT COMMUNICATION FAILURE */ 3044 - buffer[SPC_ASC_KEY_OFFSET] = 0x08; 3045 - break; 2662 + cmd->scsi_status = SAM_STAT_CHECK_CONDITION; 2663 + cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER; 2664 + rc = translate_sense_reason(cmd, reason); 2665 + if (rc) 2666 + return rc; 3046 2667 } 3047 - /* 3048 - * This code uses linux/include/scsi/scsi.h SAM status codes! 3049 - */ 3050 - cmd->scsi_status = SAM_STAT_CHECK_CONDITION; 3051 - /* 3052 - * Automatically padded, this value is encoded in the fabric's 3053 - * data_length response PDU containing the SCSI defined sense data. 3054 - */ 3055 - cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER; 3056 2668 3057 - after_reason: 3058 2669 trace_target_cmd_complete(cmd); 3059 2670 return cmd->se_tfo->queue_status(cmd); 3060 2671 }

+4 -10

drivers/target/target_core_user.c

··· 25 25 #include <linux/parser.h> 26 26 #include <linux/vmalloc.h> 27 27 #include <linux/uio_driver.h> 28 + #include <linux/stringify.h> 28 29 #include <net/genetlink.h> 29 30 #include <scsi/scsi_common.h> 30 31 #include <scsi/scsi_proto.h> ··· 539 538 UPDATE_HEAD(udev->data_tail, cmd->data_length, udev->data_size); 540 539 pr_warn("TCMU: Userspace set UNKNOWN_OP flag on se_cmd %p\n", 541 540 cmd->se_cmd); 542 - transport_generic_request_failure(cmd->se_cmd, 543 - TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE); 544 - cmd->se_cmd = NULL; 545 - kmem_cache_free(tcmu_cmd_cache, cmd); 546 - return; 547 - } 548 - 549 - if (entry->rsp.scsi_status == SAM_STAT_CHECK_CONDITION) { 541 + entry->rsp.scsi_status = SAM_STAT_CHECK_CONDITION; 542 + } else if (entry->rsp.scsi_status == SAM_STAT_CHECK_CONDITION) { 550 543 memcpy(se_cmd->sense_buffer, entry->rsp.sense_buffer, 551 544 se_cmd->scsi_sense_length); 552 545 ··· 572 577 static unsigned int tcmu_handle_completions(struct tcmu_dev *udev) 573 578 { 574 579 struct tcmu_mailbox *mb; 575 - LIST_HEAD(cpl_cmds); 576 580 unsigned long flags; 577 581 int handled = 0; 578 582 ··· 899 905 WARN_ON(!PAGE_ALIGNED(udev->data_off)); 900 906 WARN_ON(udev->data_size % PAGE_SIZE); 901 907 902 - info->version = xstr(TCMU_MAILBOX_VERSION); 908 + info->version = __stringify(TCMU_MAILBOX_VERSION); 903 909 904 910 info->mem[0].name = "tcm-user command & data buffer"; 905 911 info->mem[0].addr = (phys_addr_t) udev->mb_addr;

+4 -2

drivers/target/target_core_xcopy.c

··· 450 450 memset(&xcopy_pt_sess, 0, sizeof(struct se_session)); 451 451 INIT_LIST_HEAD(&xcopy_pt_sess.sess_list); 452 452 INIT_LIST_HEAD(&xcopy_pt_sess.sess_acl_list); 453 + INIT_LIST_HEAD(&xcopy_pt_sess.sess_cmd_list); 454 + spin_lock_init(&xcopy_pt_sess.sess_cmd_lock); 453 455 454 456 xcopy_pt_nacl.se_tpg = &xcopy_pt_tpg; 455 457 xcopy_pt_nacl.nacl_sess = &xcopy_pt_sess; ··· 646 644 pr_debug("XCOPY: Built READ_16: LBA: %llu Sectors: %u Length: %u\n", 647 645 (unsigned long long)src_lba, src_sectors, length); 648 646 649 - transport_init_se_cmd(se_cmd, &xcopy_pt_tfo, NULL, length, 647 + transport_init_se_cmd(se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, length, 650 648 DMA_FROM_DEVICE, 0, &xpt_cmd->sense_buffer[0]); 651 649 xop->src_pt_cmd = xpt_cmd; 652 650 ··· 706 704 pr_debug("XCOPY: Built WRITE_16: LBA: %llu Sectors: %u Length: %u\n", 707 705 (unsigned long long)dst_lba, dst_sectors, length); 708 706 709 - transport_init_se_cmd(se_cmd, &xcopy_pt_tfo, NULL, length, 707 + transport_init_se_cmd(se_cmd, &xcopy_pt_tfo, &xcopy_pt_sess, length, 710 708 DMA_TO_DEVICE, 0, &xpt_cmd->sense_buffer[0]); 711 709 xop->dst_pt_cmd = xpt_cmd; 712 710

+1 -1

drivers/target/tcm_fc/tfc_cmd.c

··· 255 255 struct ft_cmd *cmd = arg; 256 256 struct fc_frame_header *fh; 257 257 258 - if (unlikely(IS_ERR(fp))) { 258 + if (IS_ERR(fp)) { 259 259 /* XXX need to find cmd if queued */ 260 260 cmd->seq = NULL; 261 261 cmd->aborted = true;

+5

include/scsi/scsi_common.h

··· 61 61 extern bool scsi_normalize_sense(const u8 *sense_buffer, int sb_len, 62 62 struct scsi_sense_hdr *sshdr); 63 63 64 + extern void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq); 65 + int scsi_set_sense_information(u8 *buf, int buf_len, u64 info); 66 + extern const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 67 + int desc_type); 68 + 64 69 #endif /* _SCSI_COMMON_H_ */

+1 -5

include/scsi/scsi_eh.h

··· 4 4 #include <linux/scatterlist.h> 5 5 6 6 #include <scsi/scsi_cmnd.h> 7 + #include <scsi/scsi_common.h> 7 8 struct scsi_device; 8 9 struct Scsi_Host; 9 10 ··· 22 21 return ((sshdr->response_code >= 0x70) && (sshdr->response_code & 1)); 23 22 } 24 23 25 - extern const u8 * scsi_sense_desc_find(const u8 * sense_buffer, int sb_len, 26 - int desc_type); 27 - 28 24 extern int scsi_get_sense_info_fld(const u8 * sense_buffer, int sb_len, 29 25 u64 * info_out); 30 - 31 - extern void scsi_build_sense_buffer(int desc, u8 *buf, u8 key, u8 asc, u8 ascq); 32 26 33 27 extern int scsi_ioctl_reset(struct scsi_device *, int __user *); 34 28

+7 -8

include/target/iscsi/iscsi_target_core.h

··· 62 62 /* T10 protection information disabled by default */ 63 63 #define TA_DEFAULT_T10_PI 0 64 64 #define TA_DEFAULT_FABRIC_PROT_TYPE 0 65 + /* TPG status needs to be enabled to return sendtargets discovery endpoint info */ 66 + #define TA_DEFAULT_TPG_ENABLED_SENDTARGETS 1 65 67 66 68 #define ISCSI_IOV_DATA_BUFFER 5 67 69 ··· 519 517 u16 cid; 520 518 /* Remote TCP Port */ 521 519 u16 login_port; 522 - u16 local_port; 523 520 int net_size; 524 521 int login_family; 525 522 u32 auth_id; ··· 528 527 u32 exp_statsn; 529 528 /* Per connection status sequence number */ 530 529 u32 stat_sn; 531 - #define IPV6_ADDRESS_SPACE 48 532 - unsigned char login_ip[IPV6_ADDRESS_SPACE]; 533 - unsigned char local_ip[IPV6_ADDRESS_SPACE]; 530 + struct sockaddr_storage login_sockaddr; 531 + struct sockaddr_storage local_sockaddr; 534 532 int conn_usage_count; 535 533 int conn_waiting_on_uc; 536 534 atomic_t check_immediate_queue; ··· 636 636 /* session wide counter: expected command sequence number */ 637 637 u32 exp_cmd_sn; 638 638 /* session wide counter: maximum allowed command sequence number */ 639 - u32 max_cmd_sn; 639 + atomic_t max_cmd_sn; 640 640 struct list_head sess_ooo_cmdsn_list; 641 641 642 642 /* LIO specific session ID */ ··· 764 764 u32 default_erl; 765 765 u8 t10_pi; 766 766 u32 fabric_prot_type; 767 + u32 tpg_enabled_sendtargets; 767 768 struct iscsi_portal_group *tpg; 768 769 }; 769 770 ··· 777 776 enum iscsi_timer_flags_table np_login_timer_flags; 778 777 u32 np_exports; 779 778 enum np_flags_table np_flags; 780 - unsigned char np_ip[IPV6_ADDRESS_SPACE]; 781 - u16 np_port; 782 779 spinlock_t np_thread_lock; 783 780 struct completion np_restart_comp; 784 781 struct socket *np_socket; 785 - struct __kernel_sockaddr_storage np_sockaddr; 782 + struct sockaddr_storage np_sockaddr; 786 783 struct task_struct *np_thread; 787 784 struct timer_list np_login_timer; 788 785 void *np_context;

+1 -1

include/target/iscsi/iscsi_target_stat.h

··· 50 50 u64 last_fail_time; /* time stamp (jiffies) */ 51 51 u32 last_fail_type; 52 52 int last_intr_fail_ip_family; 53 - unsigned char last_intr_fail_ip_addr[IPV6_ADDRESS_SPACE]; 53 + struct sockaddr_storage last_intr_fail_sockaddr; 54 54 char last_intr_fail_name[224]; 55 55 } ____cacheline_aligned; 56 56

+1 -1

include/target/iscsi/iscsi_transport.h

··· 9 9 int priv_size; 10 10 struct module *owner; 11 11 struct list_head t_node; 12 - int (*iscsit_setup_np)(struct iscsi_np *, struct __kernel_sockaddr_storage *); 12 + int (*iscsit_setup_np)(struct iscsi_np *, struct sockaddr_storage *); 13 13 int (*iscsit_accept_np)(struct iscsi_np *, struct iscsi_conn *); 14 14 void (*iscsit_free_np)(struct iscsi_np *); 15 15 void (*iscsit_wait_conn)(struct iscsi_conn *);

+2

include/target/target_core_backend.h

··· 93 93 sense_reason_t passthrough_parse_cdb(struct se_cmd *cmd, 94 94 sense_reason_t (*exec_cmd)(struct se_cmd *cmd)); 95 95 96 + bool target_sense_desc_format(struct se_device *dev); 97 + 96 98 #endif /* TARGET_CORE_BACKEND_H */

+9 -18

include/target/target_core_base.h

··· 6 6 #include <linux/dma-mapping.h> 7 7 #include <linux/blkdev.h> 8 8 #include <linux/percpu_ida.h> 9 + #include <linux/t10-pi.h> 9 10 #include <net/sock.h> 10 11 #include <net/tcp.h> 11 12 ··· 427 426 TARGET_DIF_CHECK_REFTAG = 0x1 << 2, 428 427 }; 429 428 430 - struct se_dif_v1_tuple { 431 - __be16 guard_tag; 432 - __be16 app_tag; 433 - __be32 ref_tag; 434 - }; 435 - 436 429 /* for sam_task_attr */ 437 430 #define TCM_SIMPLE_TAG 0x20 438 431 #define TCM_HEAD_TAG 0x21 ··· 439 444 u8 scsi_asc; 440 445 u8 scsi_ascq; 441 446 u16 scsi_sense_length; 447 + unsigned cmd_wait_set:1; 448 + unsigned unknown_data_length:1; 449 + bool state_active:1; 442 450 u64 tag; /* SAM command identifier aka task tag */ 443 451 /* Delay for ALUA Active/NonOptimized state access in milliseconds */ 444 452 int alua_nonop_delay; ··· 453 455 unsigned int map_tag; 454 456 /* Transport protocol dependent state, see transport_state_table */ 455 457 enum transport_state_table t_state; 456 - unsigned cmd_wait_set:1; 457 - unsigned unknown_data_length:1; 458 458 /* See se_cmd_flags_table */ 459 459 u32 se_cmd_flags; 460 - u32 se_ordered_id; 461 460 /* Total size in bytes associated with command */ 462 461 u32 data_length; 463 462 u32 residual_count; ··· 472 477 struct se_tmr_req *se_tmr_req; 473 478 struct list_head se_cmd_list; 474 479 struct completion cmd_wait_comp; 475 - struct kref cmd_kref; 476 480 const struct target_core_fabric_ops *se_tfo; 477 481 sense_reason_t (*execute_cmd)(struct se_cmd *); 478 482 sense_reason_t (*transport_complete_callback)(struct se_cmd *, bool); ··· 491 497 #define CMD_T_REQUEST_STOP (1 << 8) 492 498 #define CMD_T_BUSY (1 << 9) 493 499 spinlock_t t_state_lock; 500 + struct kref cmd_kref; 494 501 struct completion t_transport_stop_comp; 495 502 496 503 struct work_struct work; ··· 504 509 struct scatterlist *t_bidi_data_sg; 505 510 unsigned int t_bidi_data_nents; 506 511 512 + /* Used for lun->lun_ref counting */ 513 + int lun_ref_active; 514 + 507 515 struct list_head state_list; 508 - bool state_active; 509 516 510 517 /* old task stop completion, consider merging with some of the above */ 511 518 struct completion task_stop_comp; ··· 515 518 /* backend private data */ 516 519 void *priv; 517 520 518 - /* Used for lun->lun_ref counting */ 519 - int lun_ref_active; 520 - 521 521 /* DIF related members */ 522 522 enum target_prot_op prot_op; 523 523 enum target_prot_type prot_type; 524 524 u8 prot_checks; 525 + bool prot_pto; 525 526 u32 prot_length; 526 527 u32 reftag_seed; 527 528 struct scatterlist *t_prot_sg; 528 529 unsigned int t_prot_nents; 529 530 sense_reason_t pi_err; 530 531 sector_t bad_sector; 531 - bool prot_pto; 532 532 }; 533 533 534 534 struct se_ua { ··· 592 598 }; 593 599 594 600 struct se_lun_acl { 595 - char initiatorname[TRANSPORT_IQN_LEN]; 596 601 u64 mapped_lun; 597 602 struct se_node_acl *se_lun_nacl; 598 603 struct se_lun *se_lun; ··· 678 685 #define SE_LUN_LINK_MAGIC 0xffff7771 679 686 u32 lun_link_magic; 680 687 u32 lun_access; 681 - u32 lun_flags; 682 688 u32 lun_index; 683 689 684 690 /* RELATIVE TARGET PORT IDENTIFER */ ··· 743 751 atomic_long_t write_bytes; 744 752 /* Active commands on this virtual SE device */ 745 753 atomic_t simple_cmds; 746 - atomic_t dev_ordered_id; 747 754 atomic_t dev_ordered_sync; 748 755 atomic_t dev_qf_count; 749 756 u32 export_count;

+14

include/target/target_core_fabric.h

··· 5 5 struct module *module; 6 6 const char *name; 7 7 size_t node_acl_size; 8 + /* 9 + * Limits number of scatterlist entries per SCF_SCSI_DATA_CDB payload. 10 + * Setting this value tells target-core to enforce this limit, and 11 + * report as INQUIRY EVPD=b0 MAXIMUM TRANSFER LENGTH. 12 + * 13 + * target-core will currently reset se_cmd->data_length to this 14 + * maximum size, and set UNDERFLOW residual count if length exceeds 15 + * this limit. 16 + * 17 + * XXX: Not all initiator hosts honor this block-limit EVPD 18 + * XXX: Currently assumes single PAGE_SIZE per scatterlist entry 19 + */ 20 + u32 max_data_sg_nents; 8 21 char *(*get_fabric_name)(void); 9 22 char *(*tpg_get_wwn)(struct se_portal_group *); 10 23 u16 (*tpg_get_tag)(struct se_portal_group *); ··· 165 152 void transport_generic_request_failure(struct se_cmd *, sense_reason_t); 166 153 void __target_execute_cmd(struct se_cmd *); 167 154 int transport_lookup_tmr_lun(struct se_cmd *, u64); 155 + void core_allocate_nexus_loss_ua(struct se_node_acl *acl); 168 156 169 157 struct se_node_acl *core_tpg_get_initiator_node_acl(struct se_portal_group *tpg, 170 158 unsigned char *);

-4

include/uapi/linux/target_core_user.h

··· 42 42 #define TCMU_MAILBOX_VERSION 2 43 43 #define ALIGN_SIZE 64 /* Should be enough for most CPUs */ 44 44 45 - /* See https://gcc.gnu.org/onlinedocs/cpp/Stringification.html */ 46 - #define xstr(s) str(s) 47 - #define str(s) #s 48 - 49 45 struct tcmu_mailbox { 50 46 __u16 version; 51 47 __u16 flags;

Configure Feed

Configure Feed