1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /******************************************************************************* 3 * Filename: target_core_stat.c 4 * 5 * Modern ConfigFS group context specific statistics based on original 6 * target_core_mib.c code 7 * 8 * (c) Copyright 2006-2013 Datera, Inc. 9 * 10 * Nicholas A. Bellinger <nab@linux-iscsi.org> 11 * 12 ******************************************************************************/ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/delay.h> 17 #include <linux/timer.h> 18 #include <linux/string.h> 19 #include <linux/utsname.h> 20 #include <linux/proc_fs.h> 21 #include <linux/seq_file.h> 22 #include <linux/configfs.h> 23 24 #include <target/target_core_base.h> 25 #include <target/target_core_backend.h> 26 #include <target/target_core_fabric.h> 27 28 #include "target_core_internal.h" 29 30 #ifndef INITIAL_JIFFIES 31 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ)) 32 #endif 33 34 #define SCSI_LU_INDEX 1 35 #define LU_COUNT 1 36 37 /* 38 * SCSI Device Table 39 */ 40 41 static struct se_device *to_stat_dev(struct config_item *item) 42 { 43 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item), 44 struct se_dev_stat_grps, scsi_dev_group); 45 return container_of(sgrps, struct se_device, dev_stat_grps); 46 } 47 48 static ssize_t target_stat_inst_show(struct config_item *item, char *page) 49 { 50 struct se_hba *hba = to_stat_dev(item)->se_hba; 51 52 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index); 53 } 54 55 static ssize_t target_stat_indx_show(struct config_item *item, char *page) 56 { 57 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->dev_index); 58 } 59 60 static ssize_t target_stat_role_show(struct config_item *item, char *page) 61 { 62 return snprintf(page, PAGE_SIZE, "Target\n"); 63 } 64 65 static ssize_t target_stat_ports_show(struct config_item *item, char *page) 66 { 67 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->export_count); 68 } 69 70 CONFIGFS_ATTR_RO(target_stat_, inst); 71 CONFIGFS_ATTR_RO(target_stat_, indx); 72 CONFIGFS_ATTR_RO(target_stat_, role); 73 CONFIGFS_ATTR_RO(target_stat_, ports); 74 75 static struct configfs_attribute *target_stat_scsi_dev_attrs[] = { 76 &target_stat_attr_inst, 77 &target_stat_attr_indx, 78 &target_stat_attr_role, 79 &target_stat_attr_ports, 80 NULL, 81 }; 82 83 static const struct config_item_type target_stat_scsi_dev_cit = { 84 .ct_attrs = target_stat_scsi_dev_attrs, 85 .ct_owner = THIS_MODULE, 86 }; 87 88 /* 89 * SCSI Target Device Table 90 */ 91 static struct se_device *to_stat_tgt_dev(struct config_item *item) 92 { 93 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item), 94 struct se_dev_stat_grps, scsi_tgt_dev_group); 95 return container_of(sgrps, struct se_device, dev_stat_grps); 96 } 97 98 static ssize_t target_stat_tgt_inst_show(struct config_item *item, char *page) 99 { 100 struct se_hba *hba = to_stat_tgt_dev(item)->se_hba; 101 102 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index); 103 } 104 105 static ssize_t target_stat_tgt_indx_show(struct config_item *item, char *page) 106 { 107 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_tgt_dev(item)->dev_index); 108 } 109 110 static ssize_t target_stat_tgt_num_lus_show(struct config_item *item, 111 char *page) 112 { 113 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT); 114 } 115 116 static ssize_t target_stat_tgt_status_show(struct config_item *item, 117 char *page) 118 { 119 if (to_stat_tgt_dev(item)->export_count) 120 return snprintf(page, PAGE_SIZE, "activated"); 121 else 122 return snprintf(page, PAGE_SIZE, "deactivated"); 123 } 124 125 static ssize_t target_stat_tgt_non_access_lus_show(struct config_item *item, 126 char *page) 127 { 128 int non_accessible_lus; 129 130 if (to_stat_tgt_dev(item)->export_count) 131 non_accessible_lus = 0; 132 else 133 non_accessible_lus = 1; 134 135 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus); 136 } 137 138 static ssize_t target_stat_tgt_resets_show(struct config_item *item, 139 char *page) 140 { 141 return snprintf(page, PAGE_SIZE, "%lu\n", 142 atomic_long_read(&to_stat_tgt_dev(item)->num_resets)); 143 } 144 145 static ssize_t target_stat_tgt_aborts_complete_show(struct config_item *item, 146 char *page) 147 { 148 return snprintf(page, PAGE_SIZE, "%lu\n", 149 atomic_long_read(&to_stat_tgt_dev(item)->aborts_complete)); 150 } 151 152 static ssize_t target_stat_tgt_aborts_no_task_show(struct config_item *item, 153 char *page) 154 { 155 return snprintf(page, PAGE_SIZE, "%lu\n", 156 atomic_long_read(&to_stat_tgt_dev(item)->aborts_no_task)); 157 } 158 159 CONFIGFS_ATTR_RO(target_stat_tgt_, inst); 160 CONFIGFS_ATTR_RO(target_stat_tgt_, indx); 161 CONFIGFS_ATTR_RO(target_stat_tgt_, num_lus); 162 CONFIGFS_ATTR_RO(target_stat_tgt_, status); 163 CONFIGFS_ATTR_RO(target_stat_tgt_, non_access_lus); 164 CONFIGFS_ATTR_RO(target_stat_tgt_, resets); 165 CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_complete); 166 CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_no_task); 167 168 static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = { 169 &target_stat_tgt_attr_inst, 170 &target_stat_tgt_attr_indx, 171 &target_stat_tgt_attr_num_lus, 172 &target_stat_tgt_attr_status, 173 &target_stat_tgt_attr_non_access_lus, 174 &target_stat_tgt_attr_resets, 175 &target_stat_tgt_attr_aborts_complete, 176 &target_stat_tgt_attr_aborts_no_task, 177 NULL, 178 }; 179 180 static const struct config_item_type target_stat_scsi_tgt_dev_cit = { 181 .ct_attrs = target_stat_scsi_tgt_dev_attrs, 182 .ct_owner = THIS_MODULE, 183 }; 184 185 /* 186 * SCSI Logical Unit Table 187 */ 188 189 static struct se_device *to_stat_lu_dev(struct config_item *item) 190 { 191 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item), 192 struct se_dev_stat_grps, scsi_lu_group); 193 return container_of(sgrps, struct se_device, dev_stat_grps); 194 } 195 196 static ssize_t target_stat_lu_inst_show(struct config_item *item, char *page) 197 { 198 struct se_hba *hba = to_stat_lu_dev(item)->se_hba; 199 200 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index); 201 } 202 203 static ssize_t target_stat_lu_dev_show(struct config_item *item, char *page) 204 { 205 return snprintf(page, PAGE_SIZE, "%u\n", 206 to_stat_lu_dev(item)->dev_index); 207 } 208 209 static ssize_t target_stat_lu_indx_show(struct config_item *item, char *page) 210 { 211 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX); 212 } 213 214 static ssize_t target_stat_lu_lun_show(struct config_item *item, char *page) 215 { 216 /* FIXME: scsiLuDefaultLun */ 217 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0); 218 } 219 220 static ssize_t target_stat_lu_lu_name_show(struct config_item *item, char *page) 221 { 222 struct se_device *dev = to_stat_lu_dev(item); 223 224 /* scsiLuWwnName */ 225 return snprintf(page, PAGE_SIZE, "%s\n", 226 (strlen(dev->t10_wwn.unit_serial)) ? 227 dev->t10_wwn.unit_serial : "None"); 228 } 229 230 static ssize_t target_stat_lu_vend_show(struct config_item *item, char *page) 231 { 232 struct se_device *dev = to_stat_lu_dev(item); 233 234 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_VENDOR_LEN) 235 "s\n", dev->t10_wwn.vendor); 236 } 237 238 static ssize_t target_stat_lu_prod_show(struct config_item *item, char *page) 239 { 240 struct se_device *dev = to_stat_lu_dev(item); 241 242 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_MODEL_LEN) 243 "s\n", dev->t10_wwn.model); 244 } 245 246 static ssize_t target_stat_lu_rev_show(struct config_item *item, char *page) 247 { 248 struct se_device *dev = to_stat_lu_dev(item); 249 250 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_REVISION_LEN) 251 "s\n", dev->t10_wwn.revision); 252 } 253 254 static ssize_t target_stat_lu_dev_type_show(struct config_item *item, char *page) 255 { 256 struct se_device *dev = to_stat_lu_dev(item); 257 258 /* scsiLuPeripheralType */ 259 return snprintf(page, PAGE_SIZE, "%u\n", 260 dev->transport->get_device_type(dev)); 261 } 262 263 static ssize_t target_stat_lu_status_show(struct config_item *item, char *page) 264 { 265 struct se_device *dev = to_stat_lu_dev(item); 266 267 /* scsiLuStatus */ 268 return snprintf(page, PAGE_SIZE, "%s\n", 269 (dev->export_count) ? "available" : "notavailable"); 270 } 271 272 static ssize_t target_stat_lu_state_bit_show(struct config_item *item, 273 char *page) 274 { 275 /* scsiLuState */ 276 return snprintf(page, PAGE_SIZE, "exposed\n"); 277 } 278 279 static ssize_t target_stat_lu_num_cmds_show(struct config_item *item, 280 char *page) 281 { 282 struct se_device *dev = to_stat_lu_dev(item); 283 284 /* scsiLuNumCommands */ 285 return snprintf(page, PAGE_SIZE, "%lu\n", 286 atomic_long_read(&dev->num_cmds)); 287 } 288 289 static ssize_t target_stat_lu_read_mbytes_show(struct config_item *item, 290 char *page) 291 { 292 struct se_device *dev = to_stat_lu_dev(item); 293 294 /* scsiLuReadMegaBytes */ 295 return snprintf(page, PAGE_SIZE, "%lu\n", 296 atomic_long_read(&dev->read_bytes) >> 20); 297 } 298 299 static ssize_t target_stat_lu_write_mbytes_show(struct config_item *item, 300 char *page) 301 { 302 struct se_device *dev = to_stat_lu_dev(item); 303 304 /* scsiLuWrittenMegaBytes */ 305 return snprintf(page, PAGE_SIZE, "%lu\n", 306 atomic_long_read(&dev->write_bytes) >> 20); 307 } 308 309 static ssize_t target_stat_lu_resets_show(struct config_item *item, char *page) 310 { 311 struct se_device *dev = to_stat_lu_dev(item); 312 313 /* scsiLuInResets */ 314 return snprintf(page, PAGE_SIZE, "%lu\n", 315 atomic_long_read(&dev->num_resets)); 316 } 317 318 static ssize_t target_stat_lu_full_stat_show(struct config_item *item, 319 char *page) 320 { 321 /* FIXME: scsiLuOutTaskSetFullStatus */ 322 return snprintf(page, PAGE_SIZE, "%u\n", 0); 323 } 324 325 static ssize_t target_stat_lu_hs_num_cmds_show(struct config_item *item, 326 char *page) 327 { 328 /* FIXME: scsiLuHSInCommands */ 329 return snprintf(page, PAGE_SIZE, "%u\n", 0); 330 } 331 332 static ssize_t target_stat_lu_creation_time_show(struct config_item *item, 333 char *page) 334 { 335 struct se_device *dev = to_stat_lu_dev(item); 336 337 /* scsiLuCreationTime */ 338 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time - 339 INITIAL_JIFFIES) * 100 / HZ)); 340 } 341 342 CONFIGFS_ATTR_RO(target_stat_lu_, inst); 343 CONFIGFS_ATTR_RO(target_stat_lu_, dev); 344 CONFIGFS_ATTR_RO(target_stat_lu_, indx); 345 CONFIGFS_ATTR_RO(target_stat_lu_, lun); 346 CONFIGFS_ATTR_RO(target_stat_lu_, lu_name); 347 CONFIGFS_ATTR_RO(target_stat_lu_, vend); 348 CONFIGFS_ATTR_RO(target_stat_lu_, prod); 349 CONFIGFS_ATTR_RO(target_stat_lu_, rev); 350 CONFIGFS_ATTR_RO(target_stat_lu_, dev_type); 351 CONFIGFS_ATTR_RO(target_stat_lu_, status); 352 CONFIGFS_ATTR_RO(target_stat_lu_, state_bit); 353 CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds); 354 CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes); 355 CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes); 356 CONFIGFS_ATTR_RO(target_stat_lu_, resets); 357 CONFIGFS_ATTR_RO(target_stat_lu_, full_stat); 358 CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds); 359 CONFIGFS_ATTR_RO(target_stat_lu_, creation_time); 360 361 static struct configfs_attribute *target_stat_scsi_lu_attrs[] = { 362 &target_stat_lu_attr_inst, 363 &target_stat_lu_attr_dev, 364 &target_stat_lu_attr_indx, 365 &target_stat_lu_attr_lun, 366 &target_stat_lu_attr_lu_name, 367 &target_stat_lu_attr_vend, 368 &target_stat_lu_attr_prod, 369 &target_stat_lu_attr_rev, 370 &target_stat_lu_attr_dev_type, 371 &target_stat_lu_attr_status, 372 &target_stat_lu_attr_state_bit, 373 &target_stat_lu_attr_num_cmds, 374 &target_stat_lu_attr_read_mbytes, 375 &target_stat_lu_attr_write_mbytes, 376 &target_stat_lu_attr_resets, 377 &target_stat_lu_attr_full_stat, 378 &target_stat_lu_attr_hs_num_cmds, 379 &target_stat_lu_attr_creation_time, 380 NULL, 381 }; 382 383 static const struct config_item_type target_stat_scsi_lu_cit = { 384 .ct_attrs = target_stat_scsi_lu_attrs, 385 .ct_owner = THIS_MODULE, 386 }; 387 388 /* 389 * Called from target_core_configfs.c:target_core_make_subdev() to setup 390 * the target statistics groups + configfs CITs located in target_core_stat.c 391 */ 392 void target_stat_setup_dev_default_groups(struct se_device *dev) 393 { 394 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group, 395 "scsi_dev", &target_stat_scsi_dev_cit); 396 configfs_add_default_group(&dev->dev_stat_grps.scsi_dev_group, 397 &dev->dev_stat_grps.stat_group); 398 399 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group, 400 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit); 401 configfs_add_default_group(&dev->dev_stat_grps.scsi_tgt_dev_group, 402 &dev->dev_stat_grps.stat_group); 403 404 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group, 405 "scsi_lu", &target_stat_scsi_lu_cit); 406 configfs_add_default_group(&dev->dev_stat_grps.scsi_lu_group, 407 &dev->dev_stat_grps.stat_group); 408 } 409 410 /* 411 * SCSI Port Table 412 */ 413 414 static struct se_lun *to_stat_port(struct config_item *item) 415 { 416 struct se_port_stat_grps *pgrps = container_of(to_config_group(item), 417 struct se_port_stat_grps, scsi_port_group); 418 return container_of(pgrps, struct se_lun, port_stat_grps); 419 } 420 421 static ssize_t target_stat_port_inst_show(struct config_item *item, char *page) 422 { 423 struct se_lun *lun = to_stat_port(item); 424 struct se_device *dev; 425 ssize_t ret = -ENODEV; 426 427 rcu_read_lock(); 428 dev = rcu_dereference(lun->lun_se_dev); 429 if (dev) 430 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index); 431 rcu_read_unlock(); 432 return ret; 433 } 434 435 static ssize_t target_stat_port_dev_show(struct config_item *item, char *page) 436 { 437 struct se_lun *lun = to_stat_port(item); 438 struct se_device *dev; 439 ssize_t ret = -ENODEV; 440 441 rcu_read_lock(); 442 dev = rcu_dereference(lun->lun_se_dev); 443 if (dev) 444 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index); 445 rcu_read_unlock(); 446 return ret; 447 } 448 449 static ssize_t target_stat_port_indx_show(struct config_item *item, char *page) 450 { 451 struct se_lun *lun = to_stat_port(item); 452 struct se_device *dev; 453 ssize_t ret = -ENODEV; 454 455 rcu_read_lock(); 456 dev = rcu_dereference(lun->lun_se_dev); 457 if (dev) 458 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi); 459 rcu_read_unlock(); 460 return ret; 461 } 462 463 static ssize_t target_stat_port_role_show(struct config_item *item, char *page) 464 { 465 struct se_lun *lun = to_stat_port(item); 466 struct se_device *dev; 467 ssize_t ret = -ENODEV; 468 469 rcu_read_lock(); 470 dev = rcu_dereference(lun->lun_se_dev); 471 if (dev) 472 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index); 473 rcu_read_unlock(); 474 return ret; 475 } 476 477 static ssize_t target_stat_port_busy_count_show(struct config_item *item, 478 char *page) 479 { 480 struct se_lun *lun = to_stat_port(item); 481 struct se_device *dev; 482 ssize_t ret = -ENODEV; 483 484 rcu_read_lock(); 485 dev = rcu_dereference(lun->lun_se_dev); 486 if (dev) { 487 /* FIXME: scsiPortBusyStatuses */ 488 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 489 } 490 rcu_read_unlock(); 491 return ret; 492 } 493 494 CONFIGFS_ATTR_RO(target_stat_port_, inst); 495 CONFIGFS_ATTR_RO(target_stat_port_, dev); 496 CONFIGFS_ATTR_RO(target_stat_port_, indx); 497 CONFIGFS_ATTR_RO(target_stat_port_, role); 498 CONFIGFS_ATTR_RO(target_stat_port_, busy_count); 499 500 static struct configfs_attribute *target_stat_scsi_port_attrs[] = { 501 &target_stat_port_attr_inst, 502 &target_stat_port_attr_dev, 503 &target_stat_port_attr_indx, 504 &target_stat_port_attr_role, 505 &target_stat_port_attr_busy_count, 506 NULL, 507 }; 508 509 static const struct config_item_type target_stat_scsi_port_cit = { 510 .ct_attrs = target_stat_scsi_port_attrs, 511 .ct_owner = THIS_MODULE, 512 }; 513 514 /* 515 * SCSI Target Port Table 516 */ 517 static struct se_lun *to_stat_tgt_port(struct config_item *item) 518 { 519 struct se_port_stat_grps *pgrps = container_of(to_config_group(item), 520 struct se_port_stat_grps, scsi_tgt_port_group); 521 return container_of(pgrps, struct se_lun, port_stat_grps); 522 } 523 524 static ssize_t target_stat_tgt_port_inst_show(struct config_item *item, 525 char *page) 526 { 527 struct se_lun *lun = to_stat_tgt_port(item); 528 struct se_device *dev; 529 ssize_t ret = -ENODEV; 530 531 rcu_read_lock(); 532 dev = rcu_dereference(lun->lun_se_dev); 533 if (dev) 534 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index); 535 rcu_read_unlock(); 536 return ret; 537 } 538 539 static ssize_t target_stat_tgt_port_dev_show(struct config_item *item, 540 char *page) 541 { 542 struct se_lun *lun = to_stat_tgt_port(item); 543 struct se_device *dev; 544 ssize_t ret = -ENODEV; 545 546 rcu_read_lock(); 547 dev = rcu_dereference(lun->lun_se_dev); 548 if (dev) 549 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index); 550 rcu_read_unlock(); 551 return ret; 552 } 553 554 static ssize_t target_stat_tgt_port_indx_show(struct config_item *item, 555 char *page) 556 { 557 struct se_lun *lun = to_stat_tgt_port(item); 558 struct se_device *dev; 559 ssize_t ret = -ENODEV; 560 561 rcu_read_lock(); 562 dev = rcu_dereference(lun->lun_se_dev); 563 if (dev) 564 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi); 565 rcu_read_unlock(); 566 return ret; 567 } 568 569 static ssize_t target_stat_tgt_port_name_show(struct config_item *item, 570 char *page) 571 { 572 struct se_lun *lun = to_stat_tgt_port(item); 573 struct se_portal_group *tpg = lun->lun_tpg; 574 struct se_device *dev; 575 ssize_t ret = -ENODEV; 576 577 rcu_read_lock(); 578 dev = rcu_dereference(lun->lun_se_dev); 579 if (dev) 580 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n", 581 tpg->se_tpg_tfo->fabric_name, 582 lun->lun_rtpi); 583 rcu_read_unlock(); 584 return ret; 585 } 586 587 static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item, 588 char *page) 589 { 590 struct se_lun *lun = to_stat_tgt_port(item); 591 struct se_portal_group *tpg = lun->lun_tpg; 592 struct se_device *dev; 593 ssize_t ret = -ENODEV; 594 595 rcu_read_lock(); 596 dev = rcu_dereference(lun->lun_se_dev); 597 if (dev) 598 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n", 599 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+", 600 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 601 rcu_read_unlock(); 602 return ret; 603 } 604 605 static ssize_t target_stat_tgt_port_in_cmds_show(struct config_item *item, 606 char *page) 607 { 608 struct se_lun *lun = to_stat_tgt_port(item); 609 struct se_device *dev; 610 ssize_t ret = -ENODEV; 611 612 rcu_read_lock(); 613 dev = rcu_dereference(lun->lun_se_dev); 614 if (dev) 615 ret = snprintf(page, PAGE_SIZE, "%lu\n", 616 atomic_long_read(&lun->lun_stats.cmd_pdus)); 617 rcu_read_unlock(); 618 return ret; 619 } 620 621 static ssize_t target_stat_tgt_port_write_mbytes_show(struct config_item *item, 622 char *page) 623 { 624 struct se_lun *lun = to_stat_tgt_port(item); 625 struct se_device *dev; 626 ssize_t ret = -ENODEV; 627 628 rcu_read_lock(); 629 dev = rcu_dereference(lun->lun_se_dev); 630 if (dev) 631 ret = snprintf(page, PAGE_SIZE, "%u\n", 632 (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20)); 633 rcu_read_unlock(); 634 return ret; 635 } 636 637 static ssize_t target_stat_tgt_port_read_mbytes_show(struct config_item *item, 638 char *page) 639 { 640 struct se_lun *lun = to_stat_tgt_port(item); 641 struct se_device *dev; 642 ssize_t ret = -ENODEV; 643 644 rcu_read_lock(); 645 dev = rcu_dereference(lun->lun_se_dev); 646 if (dev) 647 ret = snprintf(page, PAGE_SIZE, "%u\n", 648 (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20)); 649 rcu_read_unlock(); 650 return ret; 651 } 652 653 static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item, 654 char *page) 655 { 656 struct se_lun *lun = to_stat_tgt_port(item); 657 struct se_device *dev; 658 ssize_t ret = -ENODEV; 659 660 rcu_read_lock(); 661 dev = rcu_dereference(lun->lun_se_dev); 662 if (dev) { 663 /* FIXME: scsiTgtPortHsInCommands */ 664 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 665 } 666 rcu_read_unlock(); 667 return ret; 668 } 669 670 CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst); 671 CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev); 672 CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx); 673 CONFIGFS_ATTR_RO(target_stat_tgt_port_, name); 674 CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index); 675 CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds); 676 CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes); 677 CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes); 678 CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds); 679 680 static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = { 681 &target_stat_tgt_port_attr_inst, 682 &target_stat_tgt_port_attr_dev, 683 &target_stat_tgt_port_attr_indx, 684 &target_stat_tgt_port_attr_name, 685 &target_stat_tgt_port_attr_port_index, 686 &target_stat_tgt_port_attr_in_cmds, 687 &target_stat_tgt_port_attr_write_mbytes, 688 &target_stat_tgt_port_attr_read_mbytes, 689 &target_stat_tgt_port_attr_hs_in_cmds, 690 NULL, 691 }; 692 693 static const struct config_item_type target_stat_scsi_tgt_port_cit = { 694 .ct_attrs = target_stat_scsi_tgt_port_attrs, 695 .ct_owner = THIS_MODULE, 696 }; 697 698 /* 699 * SCSI Transport Table 700 */ 701 static struct se_lun *to_transport_stat(struct config_item *item) 702 { 703 struct se_port_stat_grps *pgrps = container_of(to_config_group(item), 704 struct se_port_stat_grps, scsi_transport_group); 705 return container_of(pgrps, struct se_lun, port_stat_grps); 706 } 707 708 static ssize_t target_stat_transport_inst_show(struct config_item *item, 709 char *page) 710 { 711 struct se_lun *lun = to_transport_stat(item); 712 struct se_device *dev; 713 ssize_t ret = -ENODEV; 714 715 rcu_read_lock(); 716 dev = rcu_dereference(lun->lun_se_dev); 717 if (dev) 718 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index); 719 rcu_read_unlock(); 720 return ret; 721 } 722 723 static ssize_t target_stat_transport_device_show(struct config_item *item, 724 char *page) 725 { 726 struct se_lun *lun = to_transport_stat(item); 727 struct se_device *dev; 728 struct se_portal_group *tpg = lun->lun_tpg; 729 ssize_t ret = -ENODEV; 730 731 rcu_read_lock(); 732 dev = rcu_dereference(lun->lun_se_dev); 733 if (dev) { 734 /* scsiTransportType */ 735 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n", 736 tpg->se_tpg_tfo->fabric_name); 737 } 738 rcu_read_unlock(); 739 return ret; 740 } 741 742 static ssize_t target_stat_transport_indx_show(struct config_item *item, 743 char *page) 744 { 745 struct se_lun *lun = to_transport_stat(item); 746 struct se_device *dev; 747 struct se_portal_group *tpg = lun->lun_tpg; 748 ssize_t ret = -ENODEV; 749 750 rcu_read_lock(); 751 dev = rcu_dereference(lun->lun_se_dev); 752 if (dev) 753 ret = snprintf(page, PAGE_SIZE, "%u\n", 754 tpg->se_tpg_tfo->tpg_get_inst_index(tpg)); 755 rcu_read_unlock(); 756 return ret; 757 } 758 759 static ssize_t target_stat_transport_dev_name_show(struct config_item *item, 760 char *page) 761 { 762 struct se_lun *lun = to_transport_stat(item); 763 struct se_device *dev; 764 struct se_portal_group *tpg = lun->lun_tpg; 765 struct t10_wwn *wwn; 766 ssize_t ret = -ENODEV; 767 768 rcu_read_lock(); 769 dev = rcu_dereference(lun->lun_se_dev); 770 if (dev) { 771 wwn = &dev->t10_wwn; 772 /* scsiTransportDevName */ 773 ret = snprintf(page, PAGE_SIZE, "%s+%s\n", 774 tpg->se_tpg_tfo->tpg_get_wwn(tpg), 775 (strlen(wwn->unit_serial)) ? wwn->unit_serial : 776 wwn->vendor); 777 } 778 rcu_read_unlock(); 779 return ret; 780 } 781 782 static ssize_t target_stat_transport_proto_id_show(struct config_item *item, 783 char *page) 784 { 785 struct se_lun *lun = to_transport_stat(item); 786 struct se_device *dev; 787 struct se_portal_group *tpg = lun->lun_tpg; 788 ssize_t ret = -ENODEV; 789 790 rcu_read_lock(); 791 dev = rcu_dereference(lun->lun_se_dev); 792 if (dev) 793 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->proto_id); 794 rcu_read_unlock(); 795 return ret; 796 } 797 798 CONFIGFS_ATTR_RO(target_stat_transport_, inst); 799 CONFIGFS_ATTR_RO(target_stat_transport_, device); 800 CONFIGFS_ATTR_RO(target_stat_transport_, indx); 801 CONFIGFS_ATTR_RO(target_stat_transport_, dev_name); 802 CONFIGFS_ATTR_RO(target_stat_transport_, proto_id); 803 804 static struct configfs_attribute *target_stat_scsi_transport_attrs[] = { 805 &target_stat_transport_attr_inst, 806 &target_stat_transport_attr_device, 807 &target_stat_transport_attr_indx, 808 &target_stat_transport_attr_dev_name, 809 &target_stat_transport_attr_proto_id, 810 NULL, 811 }; 812 813 static const struct config_item_type target_stat_scsi_transport_cit = { 814 .ct_attrs = target_stat_scsi_transport_attrs, 815 .ct_owner = THIS_MODULE, 816 }; 817 818 /* 819 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup 820 * the target port statistics groups + configfs CITs located in target_core_stat.c 821 */ 822 void target_stat_setup_port_default_groups(struct se_lun *lun) 823 { 824 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group, 825 "scsi_port", &target_stat_scsi_port_cit); 826 configfs_add_default_group(&lun->port_stat_grps.scsi_port_group, 827 &lun->port_stat_grps.stat_group); 828 829 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group, 830 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit); 831 configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group, 832 &lun->port_stat_grps.stat_group); 833 834 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group, 835 "scsi_transport", &target_stat_scsi_transport_cit); 836 configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group, 837 &lun->port_stat_grps.stat_group); 838 } 839 840 /* 841 * SCSI Authorized Initiator Table 842 */ 843 844 static struct se_lun_acl *auth_to_lacl(struct config_item *item) 845 { 846 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item), 847 struct se_ml_stat_grps, scsi_auth_intr_group); 848 return container_of(lgrps, struct se_lun_acl, ml_stat_grps); 849 } 850 851 static ssize_t target_stat_auth_inst_show(struct config_item *item, 852 char *page) 853 { 854 struct se_lun_acl *lacl = auth_to_lacl(item); 855 struct se_node_acl *nacl = lacl->se_lun_nacl; 856 struct se_dev_entry *deve; 857 struct se_portal_group *tpg; 858 ssize_t ret; 859 860 rcu_read_lock(); 861 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 862 if (!deve) { 863 rcu_read_unlock(); 864 return -ENODEV; 865 } 866 tpg = nacl->se_tpg; 867 /* scsiInstIndex */ 868 ret = snprintf(page, PAGE_SIZE, "%u\n", 869 tpg->se_tpg_tfo->tpg_get_inst_index(tpg)); 870 rcu_read_unlock(); 871 return ret; 872 } 873 874 static ssize_t target_stat_auth_dev_show(struct config_item *item, 875 char *page) 876 { 877 struct se_lun_acl *lacl = auth_to_lacl(item); 878 struct se_node_acl *nacl = lacl->se_lun_nacl; 879 struct se_dev_entry *deve; 880 ssize_t ret; 881 882 rcu_read_lock(); 883 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 884 if (!deve) { 885 rcu_read_unlock(); 886 return -ENODEV; 887 } 888 889 /* scsiDeviceIndex */ 890 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->se_lun->lun_index); 891 rcu_read_unlock(); 892 return ret; 893 } 894 895 static ssize_t target_stat_auth_port_show(struct config_item *item, 896 char *page) 897 { 898 struct se_lun_acl *lacl = auth_to_lacl(item); 899 struct se_node_acl *nacl = lacl->se_lun_nacl; 900 struct se_dev_entry *deve; 901 struct se_portal_group *tpg; 902 ssize_t ret; 903 904 rcu_read_lock(); 905 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 906 if (!deve) { 907 rcu_read_unlock(); 908 return -ENODEV; 909 } 910 tpg = nacl->se_tpg; 911 /* scsiAuthIntrTgtPortIndex */ 912 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg)); 913 rcu_read_unlock(); 914 return ret; 915 } 916 917 static ssize_t target_stat_auth_indx_show(struct config_item *item, 918 char *page) 919 { 920 struct se_lun_acl *lacl = auth_to_lacl(item); 921 struct se_node_acl *nacl = lacl->se_lun_nacl; 922 struct se_dev_entry *deve; 923 ssize_t ret; 924 925 rcu_read_lock(); 926 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 927 if (!deve) { 928 rcu_read_unlock(); 929 return -ENODEV; 930 } 931 /* scsiAuthIntrIndex */ 932 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index); 933 rcu_read_unlock(); 934 return ret; 935 } 936 937 static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item, 938 char *page) 939 { 940 struct se_lun_acl *lacl = auth_to_lacl(item); 941 struct se_node_acl *nacl = lacl->se_lun_nacl; 942 struct se_dev_entry *deve; 943 ssize_t ret; 944 945 rcu_read_lock(); 946 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 947 if (!deve) { 948 rcu_read_unlock(); 949 return -ENODEV; 950 } 951 /* scsiAuthIntrDevOrPort */ 952 ret = snprintf(page, PAGE_SIZE, "%u\n", 1); 953 rcu_read_unlock(); 954 return ret; 955 } 956 957 static ssize_t target_stat_auth_intr_name_show(struct config_item *item, 958 char *page) 959 { 960 struct se_lun_acl *lacl = auth_to_lacl(item); 961 struct se_node_acl *nacl = lacl->se_lun_nacl; 962 struct se_dev_entry *deve; 963 ssize_t ret; 964 965 rcu_read_lock(); 966 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 967 if (!deve) { 968 rcu_read_unlock(); 969 return -ENODEV; 970 } 971 /* scsiAuthIntrName */ 972 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname); 973 rcu_read_unlock(); 974 return ret; 975 } 976 977 static ssize_t target_stat_auth_map_indx_show(struct config_item *item, 978 char *page) 979 { 980 struct se_lun_acl *lacl = auth_to_lacl(item); 981 struct se_node_acl *nacl = lacl->se_lun_nacl; 982 struct se_dev_entry *deve; 983 ssize_t ret; 984 985 rcu_read_lock(); 986 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 987 if (!deve) { 988 rcu_read_unlock(); 989 return -ENODEV; 990 } 991 /* FIXME: scsiAuthIntrLunMapIndex */ 992 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 993 rcu_read_unlock(); 994 return ret; 995 } 996 997 static ssize_t target_stat_auth_att_count_show(struct config_item *item, 998 char *page) 999 { 1000 struct se_lun_acl *lacl = auth_to_lacl(item); 1001 struct se_node_acl *nacl = lacl->se_lun_nacl; 1002 struct se_dev_entry *deve; 1003 ssize_t ret; 1004 1005 rcu_read_lock(); 1006 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1007 if (!deve) { 1008 rcu_read_unlock(); 1009 return -ENODEV; 1010 } 1011 /* scsiAuthIntrAttachedTimes */ 1012 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count); 1013 rcu_read_unlock(); 1014 return ret; 1015 } 1016 1017 static ssize_t target_stat_auth_num_cmds_show(struct config_item *item, 1018 char *page) 1019 { 1020 struct se_lun_acl *lacl = auth_to_lacl(item); 1021 struct se_node_acl *nacl = lacl->se_lun_nacl; 1022 struct se_dev_entry *deve; 1023 ssize_t ret; 1024 1025 rcu_read_lock(); 1026 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1027 if (!deve) { 1028 rcu_read_unlock(); 1029 return -ENODEV; 1030 } 1031 /* scsiAuthIntrOutCommands */ 1032 ret = snprintf(page, PAGE_SIZE, "%lu\n", 1033 atomic_long_read(&deve->total_cmds)); 1034 rcu_read_unlock(); 1035 return ret; 1036 } 1037 1038 static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item, 1039 char *page) 1040 { 1041 struct se_lun_acl *lacl = auth_to_lacl(item); 1042 struct se_node_acl *nacl = lacl->se_lun_nacl; 1043 struct se_dev_entry *deve; 1044 ssize_t ret; 1045 1046 rcu_read_lock(); 1047 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1048 if (!deve) { 1049 rcu_read_unlock(); 1050 return -ENODEV; 1051 } 1052 /* scsiAuthIntrReadMegaBytes */ 1053 ret = snprintf(page, PAGE_SIZE, "%u\n", 1054 (u32)(atomic_long_read(&deve->read_bytes) >> 20)); 1055 rcu_read_unlock(); 1056 return ret; 1057 } 1058 1059 static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item, 1060 char *page) 1061 { 1062 struct se_lun_acl *lacl = auth_to_lacl(item); 1063 struct se_node_acl *nacl = lacl->se_lun_nacl; 1064 struct se_dev_entry *deve; 1065 ssize_t ret; 1066 1067 rcu_read_lock(); 1068 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1069 if (!deve) { 1070 rcu_read_unlock(); 1071 return -ENODEV; 1072 } 1073 /* scsiAuthIntrWrittenMegaBytes */ 1074 ret = snprintf(page, PAGE_SIZE, "%u\n", 1075 (u32)(atomic_long_read(&deve->write_bytes) >> 20)); 1076 rcu_read_unlock(); 1077 return ret; 1078 } 1079 1080 static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item, 1081 char *page) 1082 { 1083 struct se_lun_acl *lacl = auth_to_lacl(item); 1084 struct se_node_acl *nacl = lacl->se_lun_nacl; 1085 struct se_dev_entry *deve; 1086 ssize_t ret; 1087 1088 rcu_read_lock(); 1089 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1090 if (!deve) { 1091 rcu_read_unlock(); 1092 return -ENODEV; 1093 } 1094 /* FIXME: scsiAuthIntrHSOutCommands */ 1095 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 1096 rcu_read_unlock(); 1097 return ret; 1098 } 1099 1100 static ssize_t target_stat_auth_creation_time_show(struct config_item *item, 1101 char *page) 1102 { 1103 struct se_lun_acl *lacl = auth_to_lacl(item); 1104 struct se_node_acl *nacl = lacl->se_lun_nacl; 1105 struct se_dev_entry *deve; 1106 ssize_t ret; 1107 1108 rcu_read_lock(); 1109 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1110 if (!deve) { 1111 rcu_read_unlock(); 1112 return -ENODEV; 1113 } 1114 /* scsiAuthIntrLastCreation */ 1115 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time - 1116 INITIAL_JIFFIES) * 100 / HZ)); 1117 rcu_read_unlock(); 1118 return ret; 1119 } 1120 1121 static ssize_t target_stat_auth_row_status_show(struct config_item *item, 1122 char *page) 1123 { 1124 struct se_lun_acl *lacl = auth_to_lacl(item); 1125 struct se_node_acl *nacl = lacl->se_lun_nacl; 1126 struct se_dev_entry *deve; 1127 ssize_t ret; 1128 1129 rcu_read_lock(); 1130 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1131 if (!deve) { 1132 rcu_read_unlock(); 1133 return -ENODEV; 1134 } 1135 /* FIXME: scsiAuthIntrRowStatus */ 1136 ret = snprintf(page, PAGE_SIZE, "Ready\n"); 1137 rcu_read_unlock(); 1138 return ret; 1139 } 1140 1141 CONFIGFS_ATTR_RO(target_stat_auth_, inst); 1142 CONFIGFS_ATTR_RO(target_stat_auth_, dev); 1143 CONFIGFS_ATTR_RO(target_stat_auth_, port); 1144 CONFIGFS_ATTR_RO(target_stat_auth_, indx); 1145 CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port); 1146 CONFIGFS_ATTR_RO(target_stat_auth_, intr_name); 1147 CONFIGFS_ATTR_RO(target_stat_auth_, map_indx); 1148 CONFIGFS_ATTR_RO(target_stat_auth_, att_count); 1149 CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds); 1150 CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes); 1151 CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes); 1152 CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds); 1153 CONFIGFS_ATTR_RO(target_stat_auth_, creation_time); 1154 CONFIGFS_ATTR_RO(target_stat_auth_, row_status); 1155 1156 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = { 1157 &target_stat_auth_attr_inst, 1158 &target_stat_auth_attr_dev, 1159 &target_stat_auth_attr_port, 1160 &target_stat_auth_attr_indx, 1161 &target_stat_auth_attr_dev_or_port, 1162 &target_stat_auth_attr_intr_name, 1163 &target_stat_auth_attr_map_indx, 1164 &target_stat_auth_attr_att_count, 1165 &target_stat_auth_attr_num_cmds, 1166 &target_stat_auth_attr_read_mbytes, 1167 &target_stat_auth_attr_write_mbytes, 1168 &target_stat_auth_attr_hs_num_cmds, 1169 &target_stat_auth_attr_creation_time, 1170 &target_stat_auth_attr_row_status, 1171 NULL, 1172 }; 1173 1174 static const struct config_item_type target_stat_scsi_auth_intr_cit = { 1175 .ct_attrs = target_stat_scsi_auth_intr_attrs, 1176 .ct_owner = THIS_MODULE, 1177 }; 1178 1179 /* 1180 * SCSI Attached Initiator Port Table 1181 */ 1182 1183 static struct se_lun_acl *iport_to_lacl(struct config_item *item) 1184 { 1185 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item), 1186 struct se_ml_stat_grps, scsi_att_intr_port_group); 1187 return container_of(lgrps, struct se_lun_acl, ml_stat_grps); 1188 } 1189 1190 static ssize_t target_stat_iport_inst_show(struct config_item *item, 1191 char *page) 1192 { 1193 struct se_lun_acl *lacl = iport_to_lacl(item); 1194 struct se_node_acl *nacl = lacl->se_lun_nacl; 1195 struct se_dev_entry *deve; 1196 struct se_portal_group *tpg; 1197 ssize_t ret; 1198 1199 rcu_read_lock(); 1200 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1201 if (!deve) { 1202 rcu_read_unlock(); 1203 return -ENODEV; 1204 } 1205 tpg = nacl->se_tpg; 1206 /* scsiInstIndex */ 1207 ret = snprintf(page, PAGE_SIZE, "%u\n", 1208 tpg->se_tpg_tfo->tpg_get_inst_index(tpg)); 1209 rcu_read_unlock(); 1210 return ret; 1211 } 1212 1213 static ssize_t target_stat_iport_dev_show(struct config_item *item, 1214 char *page) 1215 { 1216 struct se_lun_acl *lacl = iport_to_lacl(item); 1217 struct se_node_acl *nacl = lacl->se_lun_nacl; 1218 struct se_dev_entry *deve; 1219 ssize_t ret; 1220 1221 rcu_read_lock(); 1222 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1223 if (!deve) { 1224 rcu_read_unlock(); 1225 return -ENODEV; 1226 } 1227 1228 /* scsiDeviceIndex */ 1229 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->se_lun->lun_index); 1230 rcu_read_unlock(); 1231 return ret; 1232 } 1233 1234 static ssize_t target_stat_iport_port_show(struct config_item *item, 1235 char *page) 1236 { 1237 struct se_lun_acl *lacl = iport_to_lacl(item); 1238 struct se_node_acl *nacl = lacl->se_lun_nacl; 1239 struct se_dev_entry *deve; 1240 struct se_portal_group *tpg; 1241 ssize_t ret; 1242 1243 rcu_read_lock(); 1244 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1245 if (!deve) { 1246 rcu_read_unlock(); 1247 return -ENODEV; 1248 } 1249 tpg = nacl->se_tpg; 1250 /* scsiPortIndex */ 1251 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg)); 1252 rcu_read_unlock(); 1253 return ret; 1254 } 1255 1256 static ssize_t target_stat_iport_indx_show(struct config_item *item, 1257 char *page) 1258 { 1259 struct se_lun_acl *lacl = iport_to_lacl(item); 1260 struct se_node_acl *nacl = lacl->se_lun_nacl; 1261 struct se_session *se_sess; 1262 struct se_portal_group *tpg; 1263 ssize_t ret; 1264 1265 spin_lock_irq(&nacl->nacl_sess_lock); 1266 se_sess = nacl->nacl_sess; 1267 if (!se_sess) { 1268 spin_unlock_irq(&nacl->nacl_sess_lock); 1269 return -ENODEV; 1270 } 1271 1272 tpg = nacl->se_tpg; 1273 /* scsiAttIntrPortIndex */ 1274 ret = snprintf(page, PAGE_SIZE, "%u\n", 1275 tpg->se_tpg_tfo->sess_get_index(se_sess)); 1276 spin_unlock_irq(&nacl->nacl_sess_lock); 1277 return ret; 1278 } 1279 1280 static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item, 1281 char *page) 1282 { 1283 struct se_lun_acl *lacl = iport_to_lacl(item); 1284 struct se_node_acl *nacl = lacl->se_lun_nacl; 1285 struct se_dev_entry *deve; 1286 ssize_t ret; 1287 1288 rcu_read_lock(); 1289 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1290 if (!deve) { 1291 rcu_read_unlock(); 1292 return -ENODEV; 1293 } 1294 /* scsiAttIntrPortAuthIntrIdx */ 1295 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index); 1296 rcu_read_unlock(); 1297 return ret; 1298 } 1299 1300 static ssize_t target_stat_iport_port_ident_show(struct config_item *item, 1301 char *page) 1302 { 1303 struct se_lun_acl *lacl = iport_to_lacl(item); 1304 struct se_node_acl *nacl = lacl->se_lun_nacl; 1305 struct se_session *se_sess; 1306 struct se_portal_group *tpg; 1307 ssize_t ret; 1308 unsigned char buf[64]; 1309 1310 spin_lock_irq(&nacl->nacl_sess_lock); 1311 se_sess = nacl->nacl_sess; 1312 if (!se_sess) { 1313 spin_unlock_irq(&nacl->nacl_sess_lock); 1314 return -ENODEV; 1315 } 1316 1317 tpg = nacl->se_tpg; 1318 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */ 1319 memset(buf, 0, 64); 1320 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) 1321 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64); 1322 1323 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf); 1324 spin_unlock_irq(&nacl->nacl_sess_lock); 1325 return ret; 1326 } 1327 1328 CONFIGFS_ATTR_RO(target_stat_iport_, inst); 1329 CONFIGFS_ATTR_RO(target_stat_iport_, dev); 1330 CONFIGFS_ATTR_RO(target_stat_iport_, port); 1331 CONFIGFS_ATTR_RO(target_stat_iport_, indx); 1332 CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx); 1333 CONFIGFS_ATTR_RO(target_stat_iport_, port_ident); 1334 1335 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = { 1336 &target_stat_iport_attr_inst, 1337 &target_stat_iport_attr_dev, 1338 &target_stat_iport_attr_port, 1339 &target_stat_iport_attr_indx, 1340 &target_stat_iport_attr_port_auth_indx, 1341 &target_stat_iport_attr_port_ident, 1342 NULL, 1343 }; 1344 1345 static const struct config_item_type target_stat_scsi_att_intr_port_cit = { 1346 .ct_attrs = target_stat_scsi_ath_intr_port_attrs, 1347 .ct_owner = THIS_MODULE, 1348 }; 1349 1350 /* 1351 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup 1352 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c 1353 */ 1354 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl) 1355 { 1356 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group, 1357 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit); 1358 configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group, 1359 &lacl->ml_stat_grps.stat_group); 1360 1361 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group, 1362 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit); 1363 configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group, 1364 &lacl->ml_stat_grps.stat_group); 1365 } 1366