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 struct se_lun *lun; 881 ssize_t ret; 882 883 rcu_read_lock(); 884 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 885 if (!deve) { 886 rcu_read_unlock(); 887 return -ENODEV; 888 } 889 lun = rcu_dereference(deve->se_lun); 890 /* scsiDeviceIndex */ 891 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index); 892 rcu_read_unlock(); 893 return ret; 894 } 895 896 static ssize_t target_stat_auth_port_show(struct config_item *item, 897 char *page) 898 { 899 struct se_lun_acl *lacl = auth_to_lacl(item); 900 struct se_node_acl *nacl = lacl->se_lun_nacl; 901 struct se_dev_entry *deve; 902 struct se_portal_group *tpg; 903 ssize_t ret; 904 905 rcu_read_lock(); 906 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 907 if (!deve) { 908 rcu_read_unlock(); 909 return -ENODEV; 910 } 911 tpg = nacl->se_tpg; 912 /* scsiAuthIntrTgtPortIndex */ 913 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg)); 914 rcu_read_unlock(); 915 return ret; 916 } 917 918 static ssize_t target_stat_auth_indx_show(struct config_item *item, 919 char *page) 920 { 921 struct se_lun_acl *lacl = auth_to_lacl(item); 922 struct se_node_acl *nacl = lacl->se_lun_nacl; 923 struct se_dev_entry *deve; 924 ssize_t ret; 925 926 rcu_read_lock(); 927 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 928 if (!deve) { 929 rcu_read_unlock(); 930 return -ENODEV; 931 } 932 /* scsiAuthIntrIndex */ 933 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index); 934 rcu_read_unlock(); 935 return ret; 936 } 937 938 static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item, 939 char *page) 940 { 941 struct se_lun_acl *lacl = auth_to_lacl(item); 942 struct se_node_acl *nacl = lacl->se_lun_nacl; 943 struct se_dev_entry *deve; 944 ssize_t ret; 945 946 rcu_read_lock(); 947 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 948 if (!deve) { 949 rcu_read_unlock(); 950 return -ENODEV; 951 } 952 /* scsiAuthIntrDevOrPort */ 953 ret = snprintf(page, PAGE_SIZE, "%u\n", 1); 954 rcu_read_unlock(); 955 return ret; 956 } 957 958 static ssize_t target_stat_auth_intr_name_show(struct config_item *item, 959 char *page) 960 { 961 struct se_lun_acl *lacl = auth_to_lacl(item); 962 struct se_node_acl *nacl = lacl->se_lun_nacl; 963 struct se_dev_entry *deve; 964 ssize_t ret; 965 966 rcu_read_lock(); 967 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 968 if (!deve) { 969 rcu_read_unlock(); 970 return -ENODEV; 971 } 972 /* scsiAuthIntrName */ 973 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname); 974 rcu_read_unlock(); 975 return ret; 976 } 977 978 static ssize_t target_stat_auth_map_indx_show(struct config_item *item, 979 char *page) 980 { 981 struct se_lun_acl *lacl = auth_to_lacl(item); 982 struct se_node_acl *nacl = lacl->se_lun_nacl; 983 struct se_dev_entry *deve; 984 ssize_t ret; 985 986 rcu_read_lock(); 987 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 988 if (!deve) { 989 rcu_read_unlock(); 990 return -ENODEV; 991 } 992 /* FIXME: scsiAuthIntrLunMapIndex */ 993 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 994 rcu_read_unlock(); 995 return ret; 996 } 997 998 static ssize_t target_stat_auth_att_count_show(struct config_item *item, 999 char *page) 1000 { 1001 struct se_lun_acl *lacl = auth_to_lacl(item); 1002 struct se_node_acl *nacl = lacl->se_lun_nacl; 1003 struct se_dev_entry *deve; 1004 ssize_t ret; 1005 1006 rcu_read_lock(); 1007 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1008 if (!deve) { 1009 rcu_read_unlock(); 1010 return -ENODEV; 1011 } 1012 /* scsiAuthIntrAttachedTimes */ 1013 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count); 1014 rcu_read_unlock(); 1015 return ret; 1016 } 1017 1018 static ssize_t target_stat_auth_num_cmds_show(struct config_item *item, 1019 char *page) 1020 { 1021 struct se_lun_acl *lacl = auth_to_lacl(item); 1022 struct se_node_acl *nacl = lacl->se_lun_nacl; 1023 struct se_dev_entry *deve; 1024 ssize_t ret; 1025 1026 rcu_read_lock(); 1027 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1028 if (!deve) { 1029 rcu_read_unlock(); 1030 return -ENODEV; 1031 } 1032 /* scsiAuthIntrOutCommands */ 1033 ret = snprintf(page, PAGE_SIZE, "%lu\n", 1034 atomic_long_read(&deve->total_cmds)); 1035 rcu_read_unlock(); 1036 return ret; 1037 } 1038 1039 static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item, 1040 char *page) 1041 { 1042 struct se_lun_acl *lacl = auth_to_lacl(item); 1043 struct se_node_acl *nacl = lacl->se_lun_nacl; 1044 struct se_dev_entry *deve; 1045 ssize_t ret; 1046 1047 rcu_read_lock(); 1048 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1049 if (!deve) { 1050 rcu_read_unlock(); 1051 return -ENODEV; 1052 } 1053 /* scsiAuthIntrReadMegaBytes */ 1054 ret = snprintf(page, PAGE_SIZE, "%u\n", 1055 (u32)(atomic_long_read(&deve->read_bytes) >> 20)); 1056 rcu_read_unlock(); 1057 return ret; 1058 } 1059 1060 static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item, 1061 char *page) 1062 { 1063 struct se_lun_acl *lacl = auth_to_lacl(item); 1064 struct se_node_acl *nacl = lacl->se_lun_nacl; 1065 struct se_dev_entry *deve; 1066 ssize_t ret; 1067 1068 rcu_read_lock(); 1069 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1070 if (!deve) { 1071 rcu_read_unlock(); 1072 return -ENODEV; 1073 } 1074 /* scsiAuthIntrWrittenMegaBytes */ 1075 ret = snprintf(page, PAGE_SIZE, "%u\n", 1076 (u32)(atomic_long_read(&deve->write_bytes) >> 20)); 1077 rcu_read_unlock(); 1078 return ret; 1079 } 1080 1081 static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item, 1082 char *page) 1083 { 1084 struct se_lun_acl *lacl = auth_to_lacl(item); 1085 struct se_node_acl *nacl = lacl->se_lun_nacl; 1086 struct se_dev_entry *deve; 1087 ssize_t ret; 1088 1089 rcu_read_lock(); 1090 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1091 if (!deve) { 1092 rcu_read_unlock(); 1093 return -ENODEV; 1094 } 1095 /* FIXME: scsiAuthIntrHSOutCommands */ 1096 ret = snprintf(page, PAGE_SIZE, "%u\n", 0); 1097 rcu_read_unlock(); 1098 return ret; 1099 } 1100 1101 static ssize_t target_stat_auth_creation_time_show(struct config_item *item, 1102 char *page) 1103 { 1104 struct se_lun_acl *lacl = auth_to_lacl(item); 1105 struct se_node_acl *nacl = lacl->se_lun_nacl; 1106 struct se_dev_entry *deve; 1107 ssize_t ret; 1108 1109 rcu_read_lock(); 1110 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1111 if (!deve) { 1112 rcu_read_unlock(); 1113 return -ENODEV; 1114 } 1115 /* scsiAuthIntrLastCreation */ 1116 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time - 1117 INITIAL_JIFFIES) * 100 / HZ)); 1118 rcu_read_unlock(); 1119 return ret; 1120 } 1121 1122 static ssize_t target_stat_auth_row_status_show(struct config_item *item, 1123 char *page) 1124 { 1125 struct se_lun_acl *lacl = auth_to_lacl(item); 1126 struct se_node_acl *nacl = lacl->se_lun_nacl; 1127 struct se_dev_entry *deve; 1128 ssize_t ret; 1129 1130 rcu_read_lock(); 1131 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1132 if (!deve) { 1133 rcu_read_unlock(); 1134 return -ENODEV; 1135 } 1136 /* FIXME: scsiAuthIntrRowStatus */ 1137 ret = snprintf(page, PAGE_SIZE, "Ready\n"); 1138 rcu_read_unlock(); 1139 return ret; 1140 } 1141 1142 CONFIGFS_ATTR_RO(target_stat_auth_, inst); 1143 CONFIGFS_ATTR_RO(target_stat_auth_, dev); 1144 CONFIGFS_ATTR_RO(target_stat_auth_, port); 1145 CONFIGFS_ATTR_RO(target_stat_auth_, indx); 1146 CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port); 1147 CONFIGFS_ATTR_RO(target_stat_auth_, intr_name); 1148 CONFIGFS_ATTR_RO(target_stat_auth_, map_indx); 1149 CONFIGFS_ATTR_RO(target_stat_auth_, att_count); 1150 CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds); 1151 CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes); 1152 CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes); 1153 CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds); 1154 CONFIGFS_ATTR_RO(target_stat_auth_, creation_time); 1155 CONFIGFS_ATTR_RO(target_stat_auth_, row_status); 1156 1157 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = { 1158 &target_stat_auth_attr_inst, 1159 &target_stat_auth_attr_dev, 1160 &target_stat_auth_attr_port, 1161 &target_stat_auth_attr_indx, 1162 &target_stat_auth_attr_dev_or_port, 1163 &target_stat_auth_attr_intr_name, 1164 &target_stat_auth_attr_map_indx, 1165 &target_stat_auth_attr_att_count, 1166 &target_stat_auth_attr_num_cmds, 1167 &target_stat_auth_attr_read_mbytes, 1168 &target_stat_auth_attr_write_mbytes, 1169 &target_stat_auth_attr_hs_num_cmds, 1170 &target_stat_auth_attr_creation_time, 1171 &target_stat_auth_attr_row_status, 1172 NULL, 1173 }; 1174 1175 static const struct config_item_type target_stat_scsi_auth_intr_cit = { 1176 .ct_attrs = target_stat_scsi_auth_intr_attrs, 1177 .ct_owner = THIS_MODULE, 1178 }; 1179 1180 /* 1181 * SCSI Attached Initiator Port Table 1182 */ 1183 1184 static struct se_lun_acl *iport_to_lacl(struct config_item *item) 1185 { 1186 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item), 1187 struct se_ml_stat_grps, scsi_att_intr_port_group); 1188 return container_of(lgrps, struct se_lun_acl, ml_stat_grps); 1189 } 1190 1191 static ssize_t target_stat_iport_inst_show(struct config_item *item, 1192 char *page) 1193 { 1194 struct se_lun_acl *lacl = iport_to_lacl(item); 1195 struct se_node_acl *nacl = lacl->se_lun_nacl; 1196 struct se_dev_entry *deve; 1197 struct se_portal_group *tpg; 1198 ssize_t ret; 1199 1200 rcu_read_lock(); 1201 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1202 if (!deve) { 1203 rcu_read_unlock(); 1204 return -ENODEV; 1205 } 1206 tpg = nacl->se_tpg; 1207 /* scsiInstIndex */ 1208 ret = snprintf(page, PAGE_SIZE, "%u\n", 1209 tpg->se_tpg_tfo->tpg_get_inst_index(tpg)); 1210 rcu_read_unlock(); 1211 return ret; 1212 } 1213 1214 static ssize_t target_stat_iport_dev_show(struct config_item *item, 1215 char *page) 1216 { 1217 struct se_lun_acl *lacl = iport_to_lacl(item); 1218 struct se_node_acl *nacl = lacl->se_lun_nacl; 1219 struct se_dev_entry *deve; 1220 struct se_lun *lun; 1221 ssize_t ret; 1222 1223 rcu_read_lock(); 1224 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1225 if (!deve) { 1226 rcu_read_unlock(); 1227 return -ENODEV; 1228 } 1229 lun = rcu_dereference(deve->se_lun); 1230 /* scsiDeviceIndex */ 1231 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index); 1232 rcu_read_unlock(); 1233 return ret; 1234 } 1235 1236 static ssize_t target_stat_iport_port_show(struct config_item *item, 1237 char *page) 1238 { 1239 struct se_lun_acl *lacl = iport_to_lacl(item); 1240 struct se_node_acl *nacl = lacl->se_lun_nacl; 1241 struct se_dev_entry *deve; 1242 struct se_portal_group *tpg; 1243 ssize_t ret; 1244 1245 rcu_read_lock(); 1246 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1247 if (!deve) { 1248 rcu_read_unlock(); 1249 return -ENODEV; 1250 } 1251 tpg = nacl->se_tpg; 1252 /* scsiPortIndex */ 1253 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg)); 1254 rcu_read_unlock(); 1255 return ret; 1256 } 1257 1258 static ssize_t target_stat_iport_indx_show(struct config_item *item, 1259 char *page) 1260 { 1261 struct se_lun_acl *lacl = iport_to_lacl(item); 1262 struct se_node_acl *nacl = lacl->se_lun_nacl; 1263 struct se_session *se_sess; 1264 struct se_portal_group *tpg; 1265 ssize_t ret; 1266 1267 spin_lock_irq(&nacl->nacl_sess_lock); 1268 se_sess = nacl->nacl_sess; 1269 if (!se_sess) { 1270 spin_unlock_irq(&nacl->nacl_sess_lock); 1271 return -ENODEV; 1272 } 1273 1274 tpg = nacl->se_tpg; 1275 /* scsiAttIntrPortIndex */ 1276 ret = snprintf(page, PAGE_SIZE, "%u\n", 1277 tpg->se_tpg_tfo->sess_get_index(se_sess)); 1278 spin_unlock_irq(&nacl->nacl_sess_lock); 1279 return ret; 1280 } 1281 1282 static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item, 1283 char *page) 1284 { 1285 struct se_lun_acl *lacl = iport_to_lacl(item); 1286 struct se_node_acl *nacl = lacl->se_lun_nacl; 1287 struct se_dev_entry *deve; 1288 ssize_t ret; 1289 1290 rcu_read_lock(); 1291 deve = target_nacl_find_deve(nacl, lacl->mapped_lun); 1292 if (!deve) { 1293 rcu_read_unlock(); 1294 return -ENODEV; 1295 } 1296 /* scsiAttIntrPortAuthIntrIdx */ 1297 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index); 1298 rcu_read_unlock(); 1299 return ret; 1300 } 1301 1302 static ssize_t target_stat_iport_port_ident_show(struct config_item *item, 1303 char *page) 1304 { 1305 struct se_lun_acl *lacl = iport_to_lacl(item); 1306 struct se_node_acl *nacl = lacl->se_lun_nacl; 1307 struct se_session *se_sess; 1308 struct se_portal_group *tpg; 1309 ssize_t ret; 1310 unsigned char buf[64]; 1311 1312 spin_lock_irq(&nacl->nacl_sess_lock); 1313 se_sess = nacl->nacl_sess; 1314 if (!se_sess) { 1315 spin_unlock_irq(&nacl->nacl_sess_lock); 1316 return -ENODEV; 1317 } 1318 1319 tpg = nacl->se_tpg; 1320 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */ 1321 memset(buf, 0, 64); 1322 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL) 1323 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64); 1324 1325 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf); 1326 spin_unlock_irq(&nacl->nacl_sess_lock); 1327 return ret; 1328 } 1329 1330 CONFIGFS_ATTR_RO(target_stat_iport_, inst); 1331 CONFIGFS_ATTR_RO(target_stat_iport_, dev); 1332 CONFIGFS_ATTR_RO(target_stat_iport_, port); 1333 CONFIGFS_ATTR_RO(target_stat_iport_, indx); 1334 CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx); 1335 CONFIGFS_ATTR_RO(target_stat_iport_, port_ident); 1336 1337 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = { 1338 &target_stat_iport_attr_inst, 1339 &target_stat_iport_attr_dev, 1340 &target_stat_iport_attr_port, 1341 &target_stat_iport_attr_indx, 1342 &target_stat_iport_attr_port_auth_indx, 1343 &target_stat_iport_attr_port_ident, 1344 NULL, 1345 }; 1346 1347 static const struct config_item_type target_stat_scsi_att_intr_port_cit = { 1348 .ct_attrs = target_stat_scsi_ath_intr_port_attrs, 1349 .ct_owner = THIS_MODULE, 1350 }; 1351 1352 /* 1353 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup 1354 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c 1355 */ 1356 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl) 1357 { 1358 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group, 1359 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit); 1360 configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group, 1361 &lacl->ml_stat_grps.stat_group); 1362 1363 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group, 1364 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit); 1365 configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group, 1366 &lacl->ml_stat_grps.stat_group); 1367 } 1368