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