drivers/target/target_core_stat.c

   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 }