drivers/target/target_core_stat.c

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