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