drivers/target/target_core_stat.c

   1 /*******************************************************************************
   2  * Filename:  target_core_stat.c
   3  *
   4  * Copyright (c) 2011 Rising Tide Systems
   5  * Copyright (c) 2011 Linux-iSCSI.org
   6  *
   7  * Modern ConfigFS group context specific statistics based on original
   8  * target_core_mib.c code
   9  *
  10  * Copyright (c) 2006-2007 SBE, Inc.  All Rights Reserved.
  11  *
  12  * Nicholas A. Bellinger <nab@linux-iscsi.org>
  13  *
  14  * This program is free software; you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation; either version 2 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with this program; if not, write to the Free Software
  26  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  *
  28  ******************************************************************************/
  29
  30 #include <linux/kernel.h>
  31 #include <linux/module.h>
  32 #include <linux/delay.h>
  33 #include <linux/timer.h>
  34 #include <linux/string.h>
  35 #include <linux/utsname.h>
  36 #include <linux/proc_fs.h>
  37 #include <linux/seq_file.h>
  38 #include <linux/blkdev.h>
  39 #include <linux/configfs.h>
  40 #include <scsi/scsi.h>
  41 #include <scsi/scsi_device.h>
  42 #include <scsi/scsi_host.h>
  43
  44 #include <target/target_core_base.h>
  45 #include <target/target_core_backend.h>
  46 #include <target/target_core_fabric.h>
  47 #include <target/target_core_configfs.h>
  48 #include <target/configfs_macros.h>
  49
  50 #include "target_core_internal.h"
  51
  52 #ifndef INITIAL_JIFFIES
  53 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  54 #endif
  55
  56 #define NONE            "None"
  57 #define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
  58
  59 #define SCSI_LU_INDEX                   1
  60 #define LU_COUNT                        1
  61
  62 /*
  63  * SCSI Device Table
  64  */
  65
  66 CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
  67 #define DEV_STAT_SCSI_DEV_ATTR(_name, _mode)                            \
  68 static struct target_stat_scsi_dev_attribute                            \
  69                         target_stat_scsi_dev_##_name =                  \
  70         __CONFIGFS_EATTR(_name, _mode,                                  \
  71         target_stat_scsi_dev_show_attr_##_name,                         \
  72         target_stat_scsi_dev_store_attr_##_name);
  73
  74 #define DEV_STAT_SCSI_DEV_ATTR_RO(_name)                                \
  75 static struct target_stat_scsi_dev_attribute                            \
  76                         target_stat_scsi_dev_##_name =                  \
  77         __CONFIGFS_EATTR_RO(_name,                                      \
  78         target_stat_scsi_dev_show_attr_##_name);
  79
  80 static ssize_t target_stat_scsi_dev_show_attr_inst(
  81         struct se_dev_stat_grps *sgrps, char *page)
  82 {
  83         struct se_subsystem_dev *se_subdev = container_of(sgrps,
  84                         struct se_subsystem_dev, dev_stat_grps);
  85         struct se_hba *hba = se_subdev->se_dev_hba;
  86         struct se_device *dev = se_subdev->se_dev_ptr;
  87
  88         if (!dev)
  89                 return -ENODEV;
  90
  91         return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
  92 }
  93 DEV_STAT_SCSI_DEV_ATTR_RO(inst);
  94
  95 static ssize_t target_stat_scsi_dev_show_attr_indx(
  96         struct se_dev_stat_grps *sgrps, char *page)
  97 {
  98         struct se_subsystem_dev *se_subdev = container_of(sgrps,
  99                         struct se_subsystem_dev, dev_stat_grps);
 100         struct se_device *dev = se_subdev->se_dev_ptr;
 101
 102         if (!dev)
 103                 return -ENODEV;
 104
 105         return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 106 }
 107 DEV_STAT_SCSI_DEV_ATTR_RO(indx);
 108
 109 static ssize_t target_stat_scsi_dev_show_attr_role(
 110         struct se_dev_stat_grps *sgrps, char *page)
 111 {
 112         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 113                         struct se_subsystem_dev, dev_stat_grps);
 114         struct se_device *dev = se_subdev->se_dev_ptr;
 115
 116         if (!dev)
 117                 return -ENODEV;
 118
 119         return snprintf(page, PAGE_SIZE, "Target\n");
 120 }
 121 DEV_STAT_SCSI_DEV_ATTR_RO(role);
 122
 123 static ssize_t target_stat_scsi_dev_show_attr_ports(
 124         struct se_dev_stat_grps *sgrps, char *page)
 125 {
 126         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 127                         struct se_subsystem_dev, dev_stat_grps);
 128         struct se_device *dev = se_subdev->se_dev_ptr;
 129
 130         if (!dev)
 131                 return -ENODEV;
 132
 133         return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
 134 }
 135 DEV_STAT_SCSI_DEV_ATTR_RO(ports);
 136
 137 CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
 138
 139 static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
 140         &target_stat_scsi_dev_inst.attr,
 141         &target_stat_scsi_dev_indx.attr,
 142         &target_stat_scsi_dev_role.attr,
 143         &target_stat_scsi_dev_ports.attr,
 144         NULL,
 145 };
 146
 147 static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
 148         .show_attribute         = target_stat_scsi_dev_attr_show,
 149         .store_attribute        = target_stat_scsi_dev_attr_store,
 150 };
 151
 152 static struct config_item_type target_stat_scsi_dev_cit = {
 153         .ct_item_ops            = &target_stat_scsi_dev_attrib_ops,
 154         .ct_attrs               = target_stat_scsi_dev_attrs,
 155         .ct_owner               = THIS_MODULE,
 156 };
 157
 158 /*
 159  * SCSI Target Device Table
 160  */
 161
 162 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
 163 #define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode)                        \
 164 static struct target_stat_scsi_tgt_dev_attribute                        \
 165                         target_stat_scsi_tgt_dev_##_name =              \
 166         __CONFIGFS_EATTR(_name, _mode,                                  \
 167         target_stat_scsi_tgt_dev_show_attr_##_name,                     \
 168         target_stat_scsi_tgt_dev_store_attr_##_name);
 169
 170 #define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name)                            \
 171 static struct target_stat_scsi_tgt_dev_attribute                        \
 172                         target_stat_scsi_tgt_dev_##_name =              \
 173         __CONFIGFS_EATTR_RO(_name,                                      \
 174         target_stat_scsi_tgt_dev_show_attr_##_name);
 175
 176 static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
 177         struct se_dev_stat_grps *sgrps, char *page)
 178 {
 179         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 180                         struct se_subsystem_dev, dev_stat_grps);
 181         struct se_hba *hba = se_subdev->se_dev_hba;
 182         struct se_device *dev = se_subdev->se_dev_ptr;
 183
 184         if (!dev)
 185                 return -ENODEV;
 186
 187         return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 188 }
 189 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
 190
 191 static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
 192         struct se_dev_stat_grps *sgrps, char *page)
 193 {
 194         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 195                         struct se_subsystem_dev, dev_stat_grps);
 196         struct se_device *dev = se_subdev->se_dev_ptr;
 197
 198         if (!dev)
 199                 return -ENODEV;
 200
 201         return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 202 }
 203 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
 204
 205 static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
 206         struct se_dev_stat_grps *sgrps, char *page)
 207 {
 208         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 209                         struct se_subsystem_dev, dev_stat_grps);
 210         struct se_device *dev = se_subdev->se_dev_ptr;
 211
 212         if (!dev)
 213                 return -ENODEV;
 214
 215         return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
 216 }
 217 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
 218
 219 static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
 220         struct se_dev_stat_grps *sgrps, char *page)
 221 {
 222         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 223                         struct se_subsystem_dev, dev_stat_grps);
 224         struct se_device *dev = se_subdev->se_dev_ptr;
 225         char status[16];
 226
 227         if (!dev)
 228                 return -ENODEV;
 229
 230         switch (dev->dev_status) {
 231         case TRANSPORT_DEVICE_ACTIVATED:
 232                 strcpy(status, "activated");
 233                 break;
 234         case TRANSPORT_DEVICE_DEACTIVATED:
 235                 strcpy(status, "deactivated");
 236                 break;
 237         case TRANSPORT_DEVICE_SHUTDOWN:
 238                 strcpy(status, "shutdown");
 239                 break;
 240         case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 241         case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 242                 strcpy(status, "offline");
 243                 break;
 244         default:
 245                 sprintf(status, "unknown(%d)", dev->dev_status);
 246                 break;
 247         }
 248
 249         return snprintf(page, PAGE_SIZE, "%s\n", status);
 250 }
 251 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
 252
 253 static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
 254         struct se_dev_stat_grps *sgrps, char *page)
 255 {
 256         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 257                         struct se_subsystem_dev, dev_stat_grps);
 258         struct se_device *dev = se_subdev->se_dev_ptr;
 259         int non_accessible_lus;
 260
 261         if (!dev)
 262                 return -ENODEV;
 263
 264         switch (dev->dev_status) {
 265         case TRANSPORT_DEVICE_ACTIVATED:
 266                 non_accessible_lus = 0;
 267                 break;
 268         case TRANSPORT_DEVICE_DEACTIVATED:
 269         case TRANSPORT_DEVICE_SHUTDOWN:
 270         case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 271         case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 272         default:
 273                 non_accessible_lus = 1;
 274                 break;
 275         }
 276
 277         return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
 278 }
 279 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
 280
 281 static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
 282         struct se_dev_stat_grps *sgrps, char *page)
 283 {
 284         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 285                         struct se_subsystem_dev, dev_stat_grps);
 286         struct se_device *dev = se_subdev->se_dev_ptr;
 287
 288         if (!dev)
 289                 return -ENODEV;
 290
 291         return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 292 }
 293 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
 294
 295
 296 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
 297
 298 static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
 299         &target_stat_scsi_tgt_dev_inst.attr,
 300         &target_stat_scsi_tgt_dev_indx.attr,
 301         &target_stat_scsi_tgt_dev_num_lus.attr,
 302         &target_stat_scsi_tgt_dev_status.attr,
 303         &target_stat_scsi_tgt_dev_non_access_lus.attr,
 304         &target_stat_scsi_tgt_dev_resets.attr,
 305         NULL,
 306 };
 307
 308 static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
 309         .show_attribute         = target_stat_scsi_tgt_dev_attr_show,
 310         .store_attribute        = target_stat_scsi_tgt_dev_attr_store,
 311 };
 312
 313 static struct config_item_type target_stat_scsi_tgt_dev_cit = {
 314         .ct_item_ops            = &target_stat_scsi_tgt_dev_attrib_ops,
 315         .ct_attrs               = target_stat_scsi_tgt_dev_attrs,
 316         .ct_owner               = THIS_MODULE,
 317 };
 318
 319 /*
 320  * SCSI Logical Unit Table
 321  */
 322
 323 CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
 324 #define DEV_STAT_SCSI_LU_ATTR(_name, _mode)                             \
 325 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 326         __CONFIGFS_EATTR(_name, _mode,                                  \
 327         target_stat_scsi_lu_show_attr_##_name,                          \
 328         target_stat_scsi_lu_store_attr_##_name);
 329
 330 #define DEV_STAT_SCSI_LU_ATTR_RO(_name)                                 \
 331 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 332         __CONFIGFS_EATTR_RO(_name,                                      \
 333         target_stat_scsi_lu_show_attr_##_name);
 334
 335 static ssize_t target_stat_scsi_lu_show_attr_inst(
 336         struct se_dev_stat_grps *sgrps, char *page)
 337 {
 338         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 339                         struct se_subsystem_dev, dev_stat_grps);
 340         struct se_hba *hba = se_subdev->se_dev_hba;
 341         struct se_device *dev = se_subdev->se_dev_ptr;
 342
 343         if (!dev)
 344                 return -ENODEV;
 345
 346         return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 347 }
 348 DEV_STAT_SCSI_LU_ATTR_RO(inst);
 349
 350 static ssize_t target_stat_scsi_lu_show_attr_dev(
 351         struct se_dev_stat_grps *sgrps, char *page)
 352 {
 353         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 354                         struct se_subsystem_dev, dev_stat_grps);
 355         struct se_device *dev = se_subdev->se_dev_ptr;
 356
 357         if (!dev)
 358                 return -ENODEV;
 359
 360         return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 361 }
 362 DEV_STAT_SCSI_LU_ATTR_RO(dev);
 363
 364 static ssize_t target_stat_scsi_lu_show_attr_indx(
 365         struct se_dev_stat_grps *sgrps, char *page)
 366 {
 367         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 368                         struct se_subsystem_dev, dev_stat_grps);
 369         struct se_device *dev = se_subdev->se_dev_ptr;
 370
 371         if (!dev)
 372                 return -ENODEV;
 373
 374         return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
 375 }
 376 DEV_STAT_SCSI_LU_ATTR_RO(indx);
 377
 378 static ssize_t target_stat_scsi_lu_show_attr_lun(
 379         struct se_dev_stat_grps *sgrps, char *page)
 380 {
 381         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 382                         struct se_subsystem_dev, dev_stat_grps);
 383         struct se_device *dev = se_subdev->se_dev_ptr;
 384
 385         if (!dev)
 386                 return -ENODEV;
 387         /* FIXME: scsiLuDefaultLun */
 388         return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
 389 }
 390 DEV_STAT_SCSI_LU_ATTR_RO(lun);
 391
 392 static ssize_t target_stat_scsi_lu_show_attr_lu_name(
 393         struct se_dev_stat_grps *sgrps, char *page)
 394 {
 395         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 396                         struct se_subsystem_dev, dev_stat_grps);
 397         struct se_device *dev = se_subdev->se_dev_ptr;
 398
 399         if (!dev)
 400                 return -ENODEV;
 401         /* scsiLuWwnName */
 402         return snprintf(page, PAGE_SIZE, "%s\n",
 403                         (strlen(dev->se_sub_dev->t10_wwn.unit_serial)) ?
 404                         dev->se_sub_dev->t10_wwn.unit_serial : "None");
 405 }
 406 DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
 407
 408 static ssize_t target_stat_scsi_lu_show_attr_vend(
 409         struct se_dev_stat_grps *sgrps, char *page)
 410 {
 411         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 412                         struct se_subsystem_dev, dev_stat_grps);
 413         struct se_device *dev = se_subdev->se_dev_ptr;
 414         int i;
 415         char str[sizeof(dev->se_sub_dev->t10_wwn.vendor)+1];
 416
 417         if (!dev)
 418                 return -ENODEV;
 419
 420         /* scsiLuVendorId */
 421         for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 422                 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.vendor[i]) ?
 423                         dev->se_sub_dev->t10_wwn.vendor[i] : ' ';
 424         str[i] = '\0';
 425         return snprintf(page, PAGE_SIZE, "%s\n", str);
 426 }
 427 DEV_STAT_SCSI_LU_ATTR_RO(vend);
 428
 429 static ssize_t target_stat_scsi_lu_show_attr_prod(
 430         struct se_dev_stat_grps *sgrps, char *page)
 431 {
 432         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 433                         struct se_subsystem_dev, dev_stat_grps);
 434         struct se_device *dev = se_subdev->se_dev_ptr;
 435         int i;
 436         char str[sizeof(dev->se_sub_dev->t10_wwn.model)+1];
 437
 438         if (!dev)
 439                 return -ENODEV;
 440
 441         /* scsiLuProductId */
 442         for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 443                 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.model[i]) ?
 444                         dev->se_sub_dev->t10_wwn.model[i] : ' ';
 445         str[i] = '\0';
 446         return snprintf(page, PAGE_SIZE, "%s\n", str);
 447 }
 448 DEV_STAT_SCSI_LU_ATTR_RO(prod);
 449
 450 static ssize_t target_stat_scsi_lu_show_attr_rev(
 451         struct se_dev_stat_grps *sgrps, char *page)
 452 {
 453         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 454                         struct se_subsystem_dev, dev_stat_grps);
 455         struct se_device *dev = se_subdev->se_dev_ptr;
 456         int i;
 457         char str[sizeof(dev->se_sub_dev->t10_wwn.revision)+1];
 458
 459         if (!dev)
 460                 return -ENODEV;
 461
 462         /* scsiLuRevisionId */
 463         for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.revision); i++)
 464                 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.revision[i]) ?
 465                         dev->se_sub_dev->t10_wwn.revision[i] : ' ';
 466         str[i] = '\0';
 467         return snprintf(page, PAGE_SIZE, "%s\n", str);
 468 }
 469 DEV_STAT_SCSI_LU_ATTR_RO(rev);
 470
 471 static ssize_t target_stat_scsi_lu_show_attr_dev_type(
 472         struct se_dev_stat_grps *sgrps, char *page)
 473 {
 474         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 475                         struct se_subsystem_dev, dev_stat_grps);
 476         struct se_device *dev = se_subdev->se_dev_ptr;
 477
 478         if (!dev)
 479                 return -ENODEV;
 480
 481         /* scsiLuPeripheralType */
 482         return snprintf(page, PAGE_SIZE, "%u\n",
 483                         dev->transport->get_device_type(dev));
 484 }
 485 DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
 486
 487 static ssize_t target_stat_scsi_lu_show_attr_status(
 488         struct se_dev_stat_grps *sgrps, char *page)
 489 {
 490         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 491                         struct se_subsystem_dev, dev_stat_grps);
 492         struct se_device *dev = se_subdev->se_dev_ptr;
 493
 494         if (!dev)
 495                 return -ENODEV;
 496
 497         /* scsiLuStatus */
 498         return snprintf(page, PAGE_SIZE, "%s\n",
 499                 (dev->dev_status == TRANSPORT_DEVICE_ACTIVATED) ?
 500                 "available" : "notavailable");
 501 }
 502 DEV_STAT_SCSI_LU_ATTR_RO(status);
 503
 504 static ssize_t target_stat_scsi_lu_show_attr_state_bit(
 505         struct se_dev_stat_grps *sgrps, char *page)
 506 {
 507         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 508                         struct se_subsystem_dev, dev_stat_grps);
 509         struct se_device *dev = se_subdev->se_dev_ptr;
 510
 511         if (!dev)
 512                 return -ENODEV;
 513
 514         /* scsiLuState */
 515         return snprintf(page, PAGE_SIZE, "exposed\n");
 516 }
 517 DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
 518
 519 static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
 520         struct se_dev_stat_grps *sgrps, char *page)
 521 {
 522         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 523                         struct se_subsystem_dev, dev_stat_grps);
 524         struct se_device *dev = se_subdev->se_dev_ptr;
 525
 526         if (!dev)
 527                 return -ENODEV;
 528
 529         /* scsiLuNumCommands */
 530         return snprintf(page, PAGE_SIZE, "%llu\n",
 531                         (unsigned long long)dev->num_cmds);
 532 }
 533 DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
 534
 535 static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
 536         struct se_dev_stat_grps *sgrps, char *page)
 537 {
 538         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 539                         struct se_subsystem_dev, dev_stat_grps);
 540         struct se_device *dev = se_subdev->se_dev_ptr;
 541
 542         if (!dev)
 543                 return -ENODEV;
 544
 545         /* scsiLuReadMegaBytes */
 546         return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->read_bytes >> 20));
 547 }
 548 DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
 549
 550 static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
 551         struct se_dev_stat_grps *sgrps, char *page)
 552 {
 553         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 554                         struct se_subsystem_dev, dev_stat_grps);
 555         struct se_device *dev = se_subdev->se_dev_ptr;
 556
 557         if (!dev)
 558                 return -ENODEV;
 559
 560         /* scsiLuWrittenMegaBytes */
 561         return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->write_bytes >> 20));
 562 }
 563 DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
 564
 565 static ssize_t target_stat_scsi_lu_show_attr_resets(
 566         struct se_dev_stat_grps *sgrps, char *page)
 567 {
 568         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 569                         struct se_subsystem_dev, dev_stat_grps);
 570         struct se_device *dev = se_subdev->se_dev_ptr;
 571
 572         if (!dev)
 573                 return -ENODEV;
 574
 575         /* scsiLuInResets */
 576         return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 577 }
 578 DEV_STAT_SCSI_LU_ATTR_RO(resets);
 579
 580 static ssize_t target_stat_scsi_lu_show_attr_full_stat(
 581         struct se_dev_stat_grps *sgrps, char *page)
 582 {
 583         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 584                         struct se_subsystem_dev, dev_stat_grps);
 585         struct se_device *dev = se_subdev->se_dev_ptr;
 586
 587         if (!dev)
 588                 return -ENODEV;
 589
 590         /* FIXME: scsiLuOutTaskSetFullStatus */
 591         return snprintf(page, PAGE_SIZE, "%u\n", 0);
 592 }
 593 DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
 594
 595 static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
 596         struct se_dev_stat_grps *sgrps, char *page)
 597 {
 598         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 599                         struct se_subsystem_dev, dev_stat_grps);
 600         struct se_device *dev = se_subdev->se_dev_ptr;
 601
 602         if (!dev)
 603                 return -ENODEV;
 604
 605         /* FIXME: scsiLuHSInCommands */
 606         return snprintf(page, PAGE_SIZE, "%u\n", 0);
 607 }
 608 DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
 609
 610 static ssize_t target_stat_scsi_lu_show_attr_creation_time(
 611         struct se_dev_stat_grps *sgrps, char *page)
 612 {
 613         struct se_subsystem_dev *se_subdev = container_of(sgrps,
 614                         struct se_subsystem_dev, dev_stat_grps);
 615         struct se_device *dev = se_subdev->se_dev_ptr;
 616
 617         if (!dev)
 618                 return -ENODEV;
 619
 620         /* scsiLuCreationTime */
 621         return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
 622                                 INITIAL_JIFFIES) * 100 / HZ));
 623 }
 624 DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
 625
 626 CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
 627
 628 static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
 629         &target_stat_scsi_lu_inst.attr,
 630         &target_stat_scsi_lu_dev.attr,
 631         &target_stat_scsi_lu_indx.attr,
 632         &target_stat_scsi_lu_lun.attr,
 633         &target_stat_scsi_lu_lu_name.attr,
 634         &target_stat_scsi_lu_vend.attr,
 635         &target_stat_scsi_lu_prod.attr,
 636         &target_stat_scsi_lu_rev.attr,
 637         &target_stat_scsi_lu_dev_type.attr,
 638         &target_stat_scsi_lu_status.attr,
 639         &target_stat_scsi_lu_state_bit.attr,
 640         &target_stat_scsi_lu_num_cmds.attr,
 641         &target_stat_scsi_lu_read_mbytes.attr,
 642         &target_stat_scsi_lu_write_mbytes.attr,
 643         &target_stat_scsi_lu_resets.attr,
 644         &target_stat_scsi_lu_full_stat.attr,
 645         &target_stat_scsi_lu_hs_num_cmds.attr,
 646         &target_stat_scsi_lu_creation_time.attr,
 647         NULL,
 648 };
 649
 650 static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
 651         .show_attribute         = target_stat_scsi_lu_attr_show,
 652         .store_attribute        = target_stat_scsi_lu_attr_store,
 653 };
 654
 655 static struct config_item_type target_stat_scsi_lu_cit = {
 656         .ct_item_ops            = &target_stat_scsi_lu_attrib_ops,
 657         .ct_attrs               = target_stat_scsi_lu_attrs,
 658         .ct_owner               = THIS_MODULE,
 659 };
 660
 661 /*
 662  * Called from target_core_configfs.c:target_core_make_subdev() to setup
 663  * the target statistics groups + configfs CITs located in target_core_stat.c
 664  */
 665 void target_stat_setup_dev_default_groups(struct se_subsystem_dev *se_subdev)
 666 {
 667         struct config_group *dev_stat_grp = &se_subdev->dev_stat_grps.stat_group;
 668
 669         config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_dev_group,
 670                         "scsi_dev", &target_stat_scsi_dev_cit);
 671         config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_tgt_dev_group,
 672                         "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 673         config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_lu_group,
 674                         "scsi_lu", &target_stat_scsi_lu_cit);
 675
 676         dev_stat_grp->default_groups[0] = &se_subdev->dev_stat_grps.scsi_dev_group;
 677         dev_stat_grp->default_groups[1] = &se_subdev->dev_stat_grps.scsi_tgt_dev_group;
 678         dev_stat_grp->default_groups[2] = &se_subdev->dev_stat_grps.scsi_lu_group;
 679         dev_stat_grp->default_groups[3] = NULL;
 680 }
 681
 682 /*
 683  * SCSI Port Table
 684  */
 685
 686 CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
 687 #define DEV_STAT_SCSI_PORT_ATTR(_name, _mode)                           \
 688 static struct target_stat_scsi_port_attribute                           \
 689                         target_stat_scsi_port_##_name =                 \
 690         __CONFIGFS_EATTR(_name, _mode,                                  \
 691         target_stat_scsi_port_show_attr_##_name,                        \
 692         target_stat_scsi_port_store_attr_##_name);
 693
 694 #define DEV_STAT_SCSI_PORT_ATTR_RO(_name)                               \
 695 static struct target_stat_scsi_port_attribute                           \
 696                         target_stat_scsi_port_##_name =                 \
 697         __CONFIGFS_EATTR_RO(_name,                                      \
 698         target_stat_scsi_port_show_attr_##_name);
 699
 700 static ssize_t target_stat_scsi_port_show_attr_inst(
 701         struct se_port_stat_grps *pgrps, char *page)
 702 {
 703         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 704         struct se_port *sep;
 705         struct se_device *dev = lun->lun_se_dev;
 706         struct se_hba *hba;
 707         ssize_t ret;
 708
 709         spin_lock(&lun->lun_sep_lock);
 710         sep = lun->lun_sep;
 711         if (!sep) {
 712                 spin_unlock(&lun->lun_sep_lock);
 713                 return -ENODEV;
 714         }
 715         hba = dev->se_hba;
 716         ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 717         spin_unlock(&lun->lun_sep_lock);
 718         return ret;
 719 }
 720 DEV_STAT_SCSI_PORT_ATTR_RO(inst);
 721
 722 static ssize_t target_stat_scsi_port_show_attr_dev(
 723         struct se_port_stat_grps *pgrps, char *page)
 724 {
 725         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 726         struct se_port *sep;
 727         struct se_device *dev = lun->lun_se_dev;
 728         ssize_t ret;
 729
 730         spin_lock(&lun->lun_sep_lock);
 731         sep = lun->lun_sep;
 732         if (!sep) {
 733                 spin_unlock(&lun->lun_sep_lock);
 734                 return -ENODEV;
 735         }
 736         ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 737         spin_unlock(&lun->lun_sep_lock);
 738         return ret;
 739 }
 740 DEV_STAT_SCSI_PORT_ATTR_RO(dev);
 741
 742 static ssize_t target_stat_scsi_port_show_attr_indx(
 743         struct se_port_stat_grps *pgrps, char *page)
 744 {
 745         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 746         struct se_port *sep;
 747         ssize_t ret;
 748
 749         spin_lock(&lun->lun_sep_lock);
 750         sep = lun->lun_sep;
 751         if (!sep) {
 752                 spin_unlock(&lun->lun_sep_lock);
 753                 return -ENODEV;
 754         }
 755         ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 756         spin_unlock(&lun->lun_sep_lock);
 757         return ret;
 758 }
 759 DEV_STAT_SCSI_PORT_ATTR_RO(indx);
 760
 761 static ssize_t target_stat_scsi_port_show_attr_role(
 762         struct se_port_stat_grps *pgrps, char *page)
 763 {
 764         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 765         struct se_device *dev = lun->lun_se_dev;
 766         struct se_port *sep;
 767         ssize_t ret;
 768
 769         if (!dev)
 770                 return -ENODEV;
 771
 772         spin_lock(&lun->lun_sep_lock);
 773         sep = lun->lun_sep;
 774         if (!sep) {
 775                 spin_unlock(&lun->lun_sep_lock);
 776                 return -ENODEV;
 777         }
 778         ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 779         spin_unlock(&lun->lun_sep_lock);
 780         return ret;
 781 }
 782 DEV_STAT_SCSI_PORT_ATTR_RO(role);
 783
 784 static ssize_t target_stat_scsi_port_show_attr_busy_count(
 785         struct se_port_stat_grps *pgrps, char *page)
 786 {
 787         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 788         struct se_port *sep;
 789         ssize_t ret;
 790
 791         spin_lock(&lun->lun_sep_lock);
 792         sep = lun->lun_sep;
 793         if (!sep) {
 794                 spin_unlock(&lun->lun_sep_lock);
 795                 return -ENODEV;
 796         }
 797         /* FIXME: scsiPortBusyStatuses  */
 798         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 799         spin_unlock(&lun->lun_sep_lock);
 800         return ret;
 801 }
 802 DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
 803
 804 CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
 805
 806 static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 807         &target_stat_scsi_port_inst.attr,
 808         &target_stat_scsi_port_dev.attr,
 809         &target_stat_scsi_port_indx.attr,
 810         &target_stat_scsi_port_role.attr,
 811         &target_stat_scsi_port_busy_count.attr,
 812         NULL,
 813 };
 814
 815 static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
 816         .show_attribute         = target_stat_scsi_port_attr_show,
 817         .store_attribute        = target_stat_scsi_port_attr_store,
 818 };
 819
 820 static struct config_item_type target_stat_scsi_port_cit = {
 821         .ct_item_ops            = &target_stat_scsi_port_attrib_ops,
 822         .ct_attrs               = target_stat_scsi_port_attrs,
 823         .ct_owner               = THIS_MODULE,
 824 };
 825
 826 /*
 827  * SCSI Target Port Table
 828  */
 829 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
 830 #define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode)                       \
 831 static struct target_stat_scsi_tgt_port_attribute                       \
 832                         target_stat_scsi_tgt_port_##_name =             \
 833         __CONFIGFS_EATTR(_name, _mode,                                  \
 834         target_stat_scsi_tgt_port_show_attr_##_name,                    \
 835         target_stat_scsi_tgt_port_store_attr_##_name);
 836
 837 #define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name)                           \
 838 static struct target_stat_scsi_tgt_port_attribute                       \
 839                         target_stat_scsi_tgt_port_##_name =             \
 840         __CONFIGFS_EATTR_RO(_name,                                      \
 841         target_stat_scsi_tgt_port_show_attr_##_name);
 842
 843 static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
 844         struct se_port_stat_grps *pgrps, char *page)
 845 {
 846         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 847         struct se_device *dev = lun->lun_se_dev;
 848         struct se_port *sep;
 849         struct se_hba *hba;
 850         ssize_t ret;
 851
 852         spin_lock(&lun->lun_sep_lock);
 853         sep = lun->lun_sep;
 854         if (!sep) {
 855                 spin_unlock(&lun->lun_sep_lock);
 856                 return -ENODEV;
 857         }
 858         hba = dev->se_hba;
 859         ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 860         spin_unlock(&lun->lun_sep_lock);
 861         return ret;
 862 }
 863 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
 864
 865 static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
 866         struct se_port_stat_grps *pgrps, char *page)
 867 {
 868         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 869         struct se_device *dev = lun->lun_se_dev;
 870         struct se_port *sep;
 871         ssize_t ret;
 872
 873         spin_lock(&lun->lun_sep_lock);
 874         sep = lun->lun_sep;
 875         if (!sep) {
 876                 spin_unlock(&lun->lun_sep_lock);
 877                 return -ENODEV;
 878         }
 879         ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 880         spin_unlock(&lun->lun_sep_lock);
 881         return ret;
 882 }
 883 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
 884
 885 static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
 886         struct se_port_stat_grps *pgrps, char *page)
 887 {
 888         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 889         struct se_port *sep;
 890         ssize_t ret;
 891
 892         spin_lock(&lun->lun_sep_lock);
 893         sep = lun->lun_sep;
 894         if (!sep) {
 895                 spin_unlock(&lun->lun_sep_lock);
 896                 return -ENODEV;
 897         }
 898         ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 899         spin_unlock(&lun->lun_sep_lock);
 900         return ret;
 901 }
 902 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
 903
 904 static ssize_t target_stat_scsi_tgt_port_show_attr_name(
 905         struct se_port_stat_grps *pgrps, char *page)
 906 {
 907         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 908         struct se_port *sep;
 909         struct se_portal_group *tpg;
 910         ssize_t ret;
 911
 912         spin_lock(&lun->lun_sep_lock);
 913         sep = lun->lun_sep;
 914         if (!sep) {
 915                 spin_unlock(&lun->lun_sep_lock);
 916                 return -ENODEV;
 917         }
 918         tpg = sep->sep_tpg;
 919
 920         ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 921                 tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
 922         spin_unlock(&lun->lun_sep_lock);
 923         return ret;
 924 }
 925 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
 926
 927 static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
 928         struct se_port_stat_grps *pgrps, char *page)
 929 {
 930         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 931         struct se_port *sep;
 932         struct se_portal_group *tpg;
 933         ssize_t ret;
 934
 935         spin_lock(&lun->lun_sep_lock);
 936         sep = lun->lun_sep;
 937         if (!sep) {
 938                 spin_unlock(&lun->lun_sep_lock);
 939                 return -ENODEV;
 940         }
 941         tpg = sep->sep_tpg;
 942
 943         ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 944                 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 945                 tpg->se_tpg_tfo->tpg_get_tag(tpg));
 946         spin_unlock(&lun->lun_sep_lock);
 947         return ret;
 948 }
 949 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
 950
 951 static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
 952         struct se_port_stat_grps *pgrps, char *page)
 953 {
 954         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 955         struct se_port *sep;
 956         ssize_t ret;
 957
 958         spin_lock(&lun->lun_sep_lock);
 959         sep = lun->lun_sep;
 960         if (!sep) {
 961                 spin_unlock(&lun->lun_sep_lock);
 962                 return -ENODEV;
 963         }
 964
 965         ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
 966         spin_unlock(&lun->lun_sep_lock);
 967         return ret;
 968 }
 969 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
 970
 971 static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
 972         struct se_port_stat_grps *pgrps, char *page)
 973 {
 974         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 975         struct se_port *sep;
 976         ssize_t ret;
 977
 978         spin_lock(&lun->lun_sep_lock);
 979         sep = lun->lun_sep;
 980         if (!sep) {
 981                 spin_unlock(&lun->lun_sep_lock);
 982                 return -ENODEV;
 983         }
 984
 985         ret = snprintf(page, PAGE_SIZE, "%u\n",
 986                         (u32)(sep->sep_stats.rx_data_octets >> 20));
 987         spin_unlock(&lun->lun_sep_lock);
 988         return ret;
 989 }
 990 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
 991
 992 static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
 993         struct se_port_stat_grps *pgrps, char *page)
 994 {
 995         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 996         struct se_port *sep;
 997         ssize_t ret;
 998
 999         spin_lock(&lun->lun_sep_lock);
1000         sep = lun->lun_sep;
1001         if (!sep) {
1002                 spin_unlock(&lun->lun_sep_lock);
1003                 return -ENODEV;
1004         }
1005
1006         ret = snprintf(page, PAGE_SIZE, "%u\n",
1007                         (u32)(sep->sep_stats.tx_data_octets >> 20));
1008         spin_unlock(&lun->lun_sep_lock);
1009         return ret;
1010 }
1011 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
1012
1013 static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
1014         struct se_port_stat_grps *pgrps, char *page)
1015 {
1016         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1017         struct se_port *sep;
1018         ssize_t ret;
1019
1020         spin_lock(&lun->lun_sep_lock);
1021         sep = lun->lun_sep;
1022         if (!sep) {
1023                 spin_unlock(&lun->lun_sep_lock);
1024                 return -ENODEV;
1025         }
1026
1027         /* FIXME: scsiTgtPortHsInCommands */
1028         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1029         spin_unlock(&lun->lun_sep_lock);
1030         return ret;
1031 }
1032 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
1033
1034 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
1035                 scsi_tgt_port_group);
1036
1037 static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
1038         &target_stat_scsi_tgt_port_inst.attr,
1039         &target_stat_scsi_tgt_port_dev.attr,
1040         &target_stat_scsi_tgt_port_indx.attr,
1041         &target_stat_scsi_tgt_port_name.attr,
1042         &target_stat_scsi_tgt_port_port_index.attr,
1043         &target_stat_scsi_tgt_port_in_cmds.attr,
1044         &target_stat_scsi_tgt_port_write_mbytes.attr,
1045         &target_stat_scsi_tgt_port_read_mbytes.attr,
1046         &target_stat_scsi_tgt_port_hs_in_cmds.attr,
1047         NULL,
1048 };
1049
1050 static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
1051         .show_attribute         = target_stat_scsi_tgt_port_attr_show,
1052         .store_attribute        = target_stat_scsi_tgt_port_attr_store,
1053 };
1054
1055 static struct config_item_type target_stat_scsi_tgt_port_cit = {
1056         .ct_item_ops            = &target_stat_scsi_tgt_port_attrib_ops,
1057         .ct_attrs               = target_stat_scsi_tgt_port_attrs,
1058         .ct_owner               = THIS_MODULE,
1059 };
1060
1061 /*
1062  * SCSI Transport Table
1063 o */
1064
1065 CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
1066 #define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode)                      \
1067 static struct target_stat_scsi_transport_attribute                      \
1068                         target_stat_scsi_transport_##_name =            \
1069         __CONFIGFS_EATTR(_name, _mode,                                  \
1070         target_stat_scsi_transport_show_attr_##_name,                   \
1071         target_stat_scsi_transport_store_attr_##_name);
1072
1073 #define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name)                          \
1074 static struct target_stat_scsi_transport_attribute                      \
1075                         target_stat_scsi_transport_##_name =            \
1076         __CONFIGFS_EATTR_RO(_name,                                      \
1077         target_stat_scsi_transport_show_attr_##_name);
1078
1079 static ssize_t target_stat_scsi_transport_show_attr_inst(
1080         struct se_port_stat_grps *pgrps, char *page)
1081 {
1082         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1083         struct se_device *dev = lun->lun_se_dev;
1084         struct se_port *sep;
1085         struct se_hba *hba;
1086         ssize_t ret;
1087
1088         spin_lock(&lun->lun_sep_lock);
1089         sep = lun->lun_sep;
1090         if (!sep) {
1091                 spin_unlock(&lun->lun_sep_lock);
1092                 return -ENODEV;
1093         }
1094
1095         hba = dev->se_hba;
1096         ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
1097         spin_unlock(&lun->lun_sep_lock);
1098         return ret;
1099 }
1100 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
1101
1102 static ssize_t target_stat_scsi_transport_show_attr_device(
1103         struct se_port_stat_grps *pgrps, char *page)
1104 {
1105         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1106         struct se_port *sep;
1107         struct se_portal_group *tpg;
1108         ssize_t ret;
1109
1110         spin_lock(&lun->lun_sep_lock);
1111         sep = lun->lun_sep;
1112         if (!sep) {
1113                 spin_unlock(&lun->lun_sep_lock);
1114                 return -ENODEV;
1115         }
1116         tpg = sep->sep_tpg;
1117         /* scsiTransportType */
1118         ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
1119                         tpg->se_tpg_tfo->get_fabric_name());
1120         spin_unlock(&lun->lun_sep_lock);
1121         return ret;
1122 }
1123 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
1124
1125 static ssize_t target_stat_scsi_transport_show_attr_indx(
1126         struct se_port_stat_grps *pgrps, char *page)
1127 {
1128         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1129         struct se_port *sep;
1130         struct se_portal_group *tpg;
1131         ssize_t ret;
1132
1133         spin_lock(&lun->lun_sep_lock);
1134         sep = lun->lun_sep;
1135         if (!sep) {
1136                 spin_unlock(&lun->lun_sep_lock);
1137                 return -ENODEV;
1138         }
1139         tpg = sep->sep_tpg;
1140         ret = snprintf(page, PAGE_SIZE, "%u\n",
1141                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1142         spin_unlock(&lun->lun_sep_lock);
1143         return ret;
1144 }
1145 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
1146
1147 static ssize_t target_stat_scsi_transport_show_attr_dev_name(
1148         struct se_port_stat_grps *pgrps, char *page)
1149 {
1150         struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1151         struct se_device *dev = lun->lun_se_dev;
1152         struct se_port *sep;
1153         struct se_portal_group *tpg;
1154         struct t10_wwn *wwn;
1155         ssize_t ret;
1156
1157         spin_lock(&lun->lun_sep_lock);
1158         sep = lun->lun_sep;
1159         if (!sep) {
1160                 spin_unlock(&lun->lun_sep_lock);
1161                 return -ENODEV;
1162         }
1163         tpg = sep->sep_tpg;
1164         wwn = &dev->se_sub_dev->t10_wwn;
1165         /* scsiTransportDevName */
1166         ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1167                         tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1168                         (strlen(wwn->unit_serial)) ? wwn->unit_serial :
1169                         wwn->vendor);
1170         spin_unlock(&lun->lun_sep_lock);
1171         return ret;
1172 }
1173 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1174
1175 CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1176                 scsi_transport_group);
1177
1178 static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1179         &target_stat_scsi_transport_inst.attr,
1180         &target_stat_scsi_transport_device.attr,
1181         &target_stat_scsi_transport_indx.attr,
1182         &target_stat_scsi_transport_dev_name.attr,
1183         NULL,
1184 };
1185
1186 static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1187         .show_attribute         = target_stat_scsi_transport_attr_show,
1188         .store_attribute        = target_stat_scsi_transport_attr_store,
1189 };
1190
1191 static struct config_item_type target_stat_scsi_transport_cit = {
1192         .ct_item_ops            = &target_stat_scsi_transport_attrib_ops,
1193         .ct_attrs               = target_stat_scsi_transport_attrs,
1194         .ct_owner               = THIS_MODULE,
1195 };
1196
1197 /*
1198  * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1199  * the target port statistics groups + configfs CITs located in target_core_stat.c
1200  */
1201 void target_stat_setup_port_default_groups(struct se_lun *lun)
1202 {
1203         struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1204
1205         config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1206                         "scsi_port", &target_stat_scsi_port_cit);
1207         config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1208                         "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1209         config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1210                         "scsi_transport", &target_stat_scsi_transport_cit);
1211
1212         port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1213         port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1214         port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1215         port_stat_grp->default_groups[3] = NULL;
1216 }
1217
1218 /*
1219  * SCSI Authorized Initiator Table
1220  */
1221
1222 CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1223 #define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode)                      \
1224 static struct target_stat_scsi_auth_intr_attribute                      \
1225                         target_stat_scsi_auth_intr_##_name =            \
1226         __CONFIGFS_EATTR(_name, _mode,                                  \
1227         target_stat_scsi_auth_intr_show_attr_##_name,                   \
1228         target_stat_scsi_auth_intr_store_attr_##_name);
1229
1230 #define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name)                          \
1231 static struct target_stat_scsi_auth_intr_attribute                      \
1232                         target_stat_scsi_auth_intr_##_name =            \
1233         __CONFIGFS_EATTR_RO(_name,                                      \
1234         target_stat_scsi_auth_intr_show_attr_##_name);
1235
1236 static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1237         struct se_ml_stat_grps *lgrps, char *page)
1238 {
1239         struct se_lun_acl *lacl = container_of(lgrps,
1240                         struct se_lun_acl, ml_stat_grps);
1241         struct se_node_acl *nacl = lacl->se_lun_nacl;
1242         struct se_dev_entry *deve;
1243         struct se_portal_group *tpg;
1244         ssize_t ret;
1245
1246         spin_lock_irq(&nacl->device_list_lock);
1247         deve = nacl->device_list[lacl->mapped_lun];
1248         if (!deve->se_lun || !deve->se_lun_acl) {
1249                 spin_unlock_irq(&nacl->device_list_lock);
1250                 return -ENODEV;
1251         }
1252         tpg = nacl->se_tpg;
1253         /* scsiInstIndex */
1254         ret = snprintf(page, PAGE_SIZE, "%u\n",
1255                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1256         spin_unlock_irq(&nacl->device_list_lock);
1257         return ret;
1258 }
1259 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1260
1261 static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1262         struct se_ml_stat_grps *lgrps, char *page)
1263 {
1264         struct se_lun_acl *lacl = container_of(lgrps,
1265                         struct se_lun_acl, ml_stat_grps);
1266         struct se_node_acl *nacl = lacl->se_lun_nacl;
1267         struct se_dev_entry *deve;
1268         struct se_lun *lun;
1269         ssize_t ret;
1270
1271         spin_lock_irq(&nacl->device_list_lock);
1272         deve = nacl->device_list[lacl->mapped_lun];
1273         if (!deve->se_lun || !deve->se_lun_acl) {
1274                 spin_unlock_irq(&nacl->device_list_lock);
1275                 return -ENODEV;
1276         }
1277         lun = deve->se_lun;
1278         /* scsiDeviceIndex */
1279         ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1280         spin_unlock_irq(&nacl->device_list_lock);
1281         return ret;
1282 }
1283 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1284
1285 static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1286         struct se_ml_stat_grps *lgrps, char *page)
1287 {
1288         struct se_lun_acl *lacl = container_of(lgrps,
1289                         struct se_lun_acl, ml_stat_grps);
1290         struct se_node_acl *nacl = lacl->se_lun_nacl;
1291         struct se_dev_entry *deve;
1292         struct se_portal_group *tpg;
1293         ssize_t ret;
1294
1295         spin_lock_irq(&nacl->device_list_lock);
1296         deve = nacl->device_list[lacl->mapped_lun];
1297         if (!deve->se_lun || !deve->se_lun_acl) {
1298                 spin_unlock_irq(&nacl->device_list_lock);
1299                 return -ENODEV;
1300         }
1301         tpg = nacl->se_tpg;
1302         /* scsiAuthIntrTgtPortIndex */
1303         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1304         spin_unlock_irq(&nacl->device_list_lock);
1305         return ret;
1306 }
1307 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1308
1309 static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1310         struct se_ml_stat_grps *lgrps, char *page)
1311 {
1312         struct se_lun_acl *lacl = container_of(lgrps,
1313                         struct se_lun_acl, ml_stat_grps);
1314         struct se_node_acl *nacl = lacl->se_lun_nacl;
1315         struct se_dev_entry *deve;
1316         ssize_t ret;
1317
1318         spin_lock_irq(&nacl->device_list_lock);
1319         deve = nacl->device_list[lacl->mapped_lun];
1320         if (!deve->se_lun || !deve->se_lun_acl) {
1321                 spin_unlock_irq(&nacl->device_list_lock);
1322                 return -ENODEV;
1323         }
1324         /* scsiAuthIntrIndex */
1325         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1326         spin_unlock_irq(&nacl->device_list_lock);
1327         return ret;
1328 }
1329 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1330
1331 static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1332         struct se_ml_stat_grps *lgrps, char *page)
1333 {
1334         struct se_lun_acl *lacl = container_of(lgrps,
1335                         struct se_lun_acl, ml_stat_grps);
1336         struct se_node_acl *nacl = lacl->se_lun_nacl;
1337         struct se_dev_entry *deve;
1338         ssize_t ret;
1339
1340         spin_lock_irq(&nacl->device_list_lock);
1341         deve = nacl->device_list[lacl->mapped_lun];
1342         if (!deve->se_lun || !deve->se_lun_acl) {
1343                 spin_unlock_irq(&nacl->device_list_lock);
1344                 return -ENODEV;
1345         }
1346         /* scsiAuthIntrDevOrPort */
1347         ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1348         spin_unlock_irq(&nacl->device_list_lock);
1349         return ret;
1350 }
1351 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1352
1353 static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1354         struct se_ml_stat_grps *lgrps, char *page)
1355 {
1356         struct se_lun_acl *lacl = container_of(lgrps,
1357                         struct se_lun_acl, ml_stat_grps);
1358         struct se_node_acl *nacl = lacl->se_lun_nacl;
1359         struct se_dev_entry *deve;
1360         ssize_t ret;
1361
1362         spin_lock_irq(&nacl->device_list_lock);
1363         deve = nacl->device_list[lacl->mapped_lun];
1364         if (!deve->se_lun || !deve->se_lun_acl) {
1365                 spin_unlock_irq(&nacl->device_list_lock);
1366                 return -ENODEV;
1367         }
1368         /* scsiAuthIntrName */
1369         ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1370         spin_unlock_irq(&nacl->device_list_lock);
1371         return ret;
1372 }
1373 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1374
1375 static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1376         struct se_ml_stat_grps *lgrps, char *page)
1377 {
1378         struct se_lun_acl *lacl = container_of(lgrps,
1379                         struct se_lun_acl, ml_stat_grps);
1380         struct se_node_acl *nacl = lacl->se_lun_nacl;
1381         struct se_dev_entry *deve;
1382         ssize_t ret;
1383
1384         spin_lock_irq(&nacl->device_list_lock);
1385         deve = nacl->device_list[lacl->mapped_lun];
1386         if (!deve->se_lun || !deve->se_lun_acl) {
1387                 spin_unlock_irq(&nacl->device_list_lock);
1388                 return -ENODEV;
1389         }
1390         /* FIXME: scsiAuthIntrLunMapIndex */
1391         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1392         spin_unlock_irq(&nacl->device_list_lock);
1393         return ret;
1394 }
1395 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1396
1397 static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1398         struct se_ml_stat_grps *lgrps, char *page)
1399 {
1400         struct se_lun_acl *lacl = container_of(lgrps,
1401                         struct se_lun_acl, ml_stat_grps);
1402         struct se_node_acl *nacl = lacl->se_lun_nacl;
1403         struct se_dev_entry *deve;
1404         ssize_t ret;
1405
1406         spin_lock_irq(&nacl->device_list_lock);
1407         deve = nacl->device_list[lacl->mapped_lun];
1408         if (!deve->se_lun || !deve->se_lun_acl) {
1409                 spin_unlock_irq(&nacl->device_list_lock);
1410                 return -ENODEV;
1411         }
1412         /* scsiAuthIntrAttachedTimes */
1413         ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1414         spin_unlock_irq(&nacl->device_list_lock);
1415         return ret;
1416 }
1417 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1418
1419 static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1420         struct se_ml_stat_grps *lgrps, char *page)
1421 {
1422         struct se_lun_acl *lacl = container_of(lgrps,
1423                         struct se_lun_acl, ml_stat_grps);
1424         struct se_node_acl *nacl = lacl->se_lun_nacl;
1425         struct se_dev_entry *deve;
1426         ssize_t ret;
1427
1428         spin_lock_irq(&nacl->device_list_lock);
1429         deve = nacl->device_list[lacl->mapped_lun];
1430         if (!deve->se_lun || !deve->se_lun_acl) {
1431                 spin_unlock_irq(&nacl->device_list_lock);
1432                 return -ENODEV;
1433         }
1434         /* scsiAuthIntrOutCommands */
1435         ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1436         spin_unlock_irq(&nacl->device_list_lock);
1437         return ret;
1438 }
1439 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1440
1441 static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1442         struct se_ml_stat_grps *lgrps, char *page)
1443 {
1444         struct se_lun_acl *lacl = container_of(lgrps,
1445                         struct se_lun_acl, ml_stat_grps);
1446         struct se_node_acl *nacl = lacl->se_lun_nacl;
1447         struct se_dev_entry *deve;
1448         ssize_t ret;
1449
1450         spin_lock_irq(&nacl->device_list_lock);
1451         deve = nacl->device_list[lacl->mapped_lun];
1452         if (!deve->se_lun || !deve->se_lun_acl) {
1453                 spin_unlock_irq(&nacl->device_list_lock);
1454                 return -ENODEV;
1455         }
1456         /* scsiAuthIntrReadMegaBytes */
1457         ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1458         spin_unlock_irq(&nacl->device_list_lock);
1459         return ret;
1460 }
1461 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1462
1463 static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1464         struct se_ml_stat_grps *lgrps, char *page)
1465 {
1466         struct se_lun_acl *lacl = container_of(lgrps,
1467                         struct se_lun_acl, ml_stat_grps);
1468         struct se_node_acl *nacl = lacl->se_lun_nacl;
1469         struct se_dev_entry *deve;
1470         ssize_t ret;
1471
1472         spin_lock_irq(&nacl->device_list_lock);
1473         deve = nacl->device_list[lacl->mapped_lun];
1474         if (!deve->se_lun || !deve->se_lun_acl) {
1475                 spin_unlock_irq(&nacl->device_list_lock);
1476                 return -ENODEV;
1477         }
1478         /* scsiAuthIntrWrittenMegaBytes */
1479         ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1480         spin_unlock_irq(&nacl->device_list_lock);
1481         return ret;
1482 }
1483 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1484
1485 static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1486         struct se_ml_stat_grps *lgrps, char *page)
1487 {
1488         struct se_lun_acl *lacl = container_of(lgrps,
1489                         struct se_lun_acl, ml_stat_grps);
1490         struct se_node_acl *nacl = lacl->se_lun_nacl;
1491         struct se_dev_entry *deve;
1492         ssize_t ret;
1493
1494         spin_lock_irq(&nacl->device_list_lock);
1495         deve = nacl->device_list[lacl->mapped_lun];
1496         if (!deve->se_lun || !deve->se_lun_acl) {
1497                 spin_unlock_irq(&nacl->device_list_lock);
1498                 return -ENODEV;
1499         }
1500         /* FIXME: scsiAuthIntrHSOutCommands */
1501         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1502         spin_unlock_irq(&nacl->device_list_lock);
1503         return ret;
1504 }
1505 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1506
1507 static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1508         struct se_ml_stat_grps *lgrps, char *page)
1509 {
1510         struct se_lun_acl *lacl = container_of(lgrps,
1511                         struct se_lun_acl, ml_stat_grps);
1512         struct se_node_acl *nacl = lacl->se_lun_nacl;
1513         struct se_dev_entry *deve;
1514         ssize_t ret;
1515
1516         spin_lock_irq(&nacl->device_list_lock);
1517         deve = nacl->device_list[lacl->mapped_lun];
1518         if (!deve->se_lun || !deve->se_lun_acl) {
1519                 spin_unlock_irq(&nacl->device_list_lock);
1520                 return -ENODEV;
1521         }
1522         /* scsiAuthIntrLastCreation */
1523         ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1524                                 INITIAL_JIFFIES) * 100 / HZ));
1525         spin_unlock_irq(&nacl->device_list_lock);
1526         return ret;
1527 }
1528 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1529
1530 static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1531         struct se_ml_stat_grps *lgrps, char *page)
1532 {
1533         struct se_lun_acl *lacl = container_of(lgrps,
1534                         struct se_lun_acl, ml_stat_grps);
1535         struct se_node_acl *nacl = lacl->se_lun_nacl;
1536         struct se_dev_entry *deve;
1537         ssize_t ret;
1538
1539         spin_lock_irq(&nacl->device_list_lock);
1540         deve = nacl->device_list[lacl->mapped_lun];
1541         if (!deve->se_lun || !deve->se_lun_acl) {
1542                 spin_unlock_irq(&nacl->device_list_lock);
1543                 return -ENODEV;
1544         }
1545         /* FIXME: scsiAuthIntrRowStatus */
1546         ret = snprintf(page, PAGE_SIZE, "Ready\n");
1547         spin_unlock_irq(&nacl->device_list_lock);
1548         return ret;
1549 }
1550 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1551
1552 CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1553                 scsi_auth_intr_group);
1554
1555 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1556         &target_stat_scsi_auth_intr_inst.attr,
1557         &target_stat_scsi_auth_intr_dev.attr,
1558         &target_stat_scsi_auth_intr_port.attr,
1559         &target_stat_scsi_auth_intr_indx.attr,
1560         &target_stat_scsi_auth_intr_dev_or_port.attr,
1561         &target_stat_scsi_auth_intr_intr_name.attr,
1562         &target_stat_scsi_auth_intr_map_indx.attr,
1563         &target_stat_scsi_auth_intr_att_count.attr,
1564         &target_stat_scsi_auth_intr_num_cmds.attr,
1565         &target_stat_scsi_auth_intr_read_mbytes.attr,
1566         &target_stat_scsi_auth_intr_write_mbytes.attr,
1567         &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1568         &target_stat_scsi_auth_intr_creation_time.attr,
1569         &target_stat_scsi_auth_intr_row_status.attr,
1570         NULL,
1571 };
1572
1573 static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1574         .show_attribute         = target_stat_scsi_auth_intr_attr_show,
1575         .store_attribute        = target_stat_scsi_auth_intr_attr_store,
1576 };
1577
1578 static struct config_item_type target_stat_scsi_auth_intr_cit = {
1579         .ct_item_ops            = &target_stat_scsi_auth_intr_attrib_ops,
1580         .ct_attrs               = target_stat_scsi_auth_intr_attrs,
1581         .ct_owner               = THIS_MODULE,
1582 };
1583
1584 /*
1585  * SCSI Attached Initiator Port Table
1586  */
1587
1588 CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1589 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode)                 \
1590 static struct target_stat_scsi_att_intr_port_attribute                  \
1591                 target_stat_scsi_att_intr_port_##_name =                \
1592         __CONFIGFS_EATTR(_name, _mode,                                  \
1593         target_stat_scsi_att_intr_port_show_attr_##_name,               \
1594         target_stat_scsi_att_intr_port_store_attr_##_name);
1595
1596 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name)                     \
1597 static struct target_stat_scsi_att_intr_port_attribute                  \
1598                 target_stat_scsi_att_intr_port_##_name =                \
1599         __CONFIGFS_EATTR_RO(_name,                                      \
1600         target_stat_scsi_att_intr_port_show_attr_##_name);
1601
1602 static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1603         struct se_ml_stat_grps *lgrps, char *page)
1604 {
1605         struct se_lun_acl *lacl = container_of(lgrps,
1606                         struct se_lun_acl, ml_stat_grps);
1607         struct se_node_acl *nacl = lacl->se_lun_nacl;
1608         struct se_dev_entry *deve;
1609         struct se_portal_group *tpg;
1610         ssize_t ret;
1611
1612         spin_lock_irq(&nacl->device_list_lock);
1613         deve = nacl->device_list[lacl->mapped_lun];
1614         if (!deve->se_lun || !deve->se_lun_acl) {
1615                 spin_unlock_irq(&nacl->device_list_lock);
1616                 return -ENODEV;
1617         }
1618         tpg = nacl->se_tpg;
1619         /* scsiInstIndex */
1620         ret = snprintf(page, PAGE_SIZE, "%u\n",
1621                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1622         spin_unlock_irq(&nacl->device_list_lock);
1623         return ret;
1624 }
1625 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1626
1627 static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1628         struct se_ml_stat_grps *lgrps, char *page)
1629 {
1630         struct se_lun_acl *lacl = container_of(lgrps,
1631                         struct se_lun_acl, ml_stat_grps);
1632         struct se_node_acl *nacl = lacl->se_lun_nacl;
1633         struct se_dev_entry *deve;
1634         struct se_lun *lun;
1635         ssize_t ret;
1636
1637         spin_lock_irq(&nacl->device_list_lock);
1638         deve = nacl->device_list[lacl->mapped_lun];
1639         if (!deve->se_lun || !deve->se_lun_acl) {
1640                 spin_unlock_irq(&nacl->device_list_lock);
1641                 return -ENODEV;
1642         }
1643         lun = deve->se_lun;
1644         /* scsiDeviceIndex */
1645         ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1646         spin_unlock_irq(&nacl->device_list_lock);
1647         return ret;
1648 }
1649 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1650
1651 static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1652         struct se_ml_stat_grps *lgrps, char *page)
1653 {
1654         struct se_lun_acl *lacl = container_of(lgrps,
1655                         struct se_lun_acl, ml_stat_grps);
1656         struct se_node_acl *nacl = lacl->se_lun_nacl;
1657         struct se_dev_entry *deve;
1658         struct se_portal_group *tpg;
1659         ssize_t ret;
1660
1661         spin_lock_irq(&nacl->device_list_lock);
1662         deve = nacl->device_list[lacl->mapped_lun];
1663         if (!deve->se_lun || !deve->se_lun_acl) {
1664                 spin_unlock_irq(&nacl->device_list_lock);
1665                 return -ENODEV;
1666         }
1667         tpg = nacl->se_tpg;
1668         /* scsiPortIndex */
1669         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1670         spin_unlock_irq(&nacl->device_list_lock);
1671         return ret;
1672 }
1673 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1674
1675 static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1676         struct se_ml_stat_grps *lgrps, char *page)
1677 {
1678         struct se_lun_acl *lacl = container_of(lgrps,
1679                         struct se_lun_acl, ml_stat_grps);
1680         struct se_node_acl *nacl = lacl->se_lun_nacl;
1681         struct se_session *se_sess;
1682         struct se_portal_group *tpg;
1683         ssize_t ret;
1684
1685         spin_lock_irq(&nacl->nacl_sess_lock);
1686         se_sess = nacl->nacl_sess;
1687         if (!se_sess) {
1688                 spin_unlock_irq(&nacl->nacl_sess_lock);
1689                 return -ENODEV;
1690         }
1691
1692         tpg = nacl->se_tpg;
1693         /* scsiAttIntrPortIndex */
1694         ret = snprintf(page, PAGE_SIZE, "%u\n",
1695                         tpg->se_tpg_tfo->sess_get_index(se_sess));
1696         spin_unlock_irq(&nacl->nacl_sess_lock);
1697         return ret;
1698 }
1699 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1700
1701 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1702         struct se_ml_stat_grps *lgrps, char *page)
1703 {
1704         struct se_lun_acl *lacl = container_of(lgrps,
1705                         struct se_lun_acl, ml_stat_grps);
1706         struct se_node_acl *nacl = lacl->se_lun_nacl;
1707         struct se_dev_entry *deve;
1708         ssize_t ret;
1709
1710         spin_lock_irq(&nacl->device_list_lock);
1711         deve = nacl->device_list[lacl->mapped_lun];
1712         if (!deve->se_lun || !deve->se_lun_acl) {
1713                 spin_unlock_irq(&nacl->device_list_lock);
1714                 return -ENODEV;
1715         }
1716         /* scsiAttIntrPortAuthIntrIdx */
1717         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1718         spin_unlock_irq(&nacl->device_list_lock);
1719         return ret;
1720 }
1721 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1722
1723 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1724         struct se_ml_stat_grps *lgrps, char *page)
1725 {
1726         struct se_lun_acl *lacl = container_of(lgrps,
1727                         struct se_lun_acl, ml_stat_grps);
1728         struct se_node_acl *nacl = lacl->se_lun_nacl;
1729         struct se_session *se_sess;
1730         struct se_portal_group *tpg;
1731         ssize_t ret;
1732         unsigned char buf[64];
1733
1734         spin_lock_irq(&nacl->nacl_sess_lock);
1735         se_sess = nacl->nacl_sess;
1736         if (!se_sess) {
1737                 spin_unlock_irq(&nacl->nacl_sess_lock);
1738                 return -ENODEV;
1739         }
1740
1741         tpg = nacl->se_tpg;
1742         /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1743         memset(buf, 0, 64);
1744         if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1745                 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1746
1747         ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1748         spin_unlock_irq(&nacl->nacl_sess_lock);
1749         return ret;
1750 }
1751 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1752
1753 CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1754                 scsi_att_intr_port_group);
1755
1756 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1757         &target_stat_scsi_att_intr_port_inst.attr,
1758         &target_stat_scsi_att_intr_port_dev.attr,
1759         &target_stat_scsi_att_intr_port_port.attr,
1760         &target_stat_scsi_att_intr_port_indx.attr,
1761         &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1762         &target_stat_scsi_att_intr_port_port_ident.attr,
1763         NULL,
1764 };
1765
1766 static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1767         .show_attribute         = target_stat_scsi_att_intr_port_attr_show,
1768         .store_attribute        = target_stat_scsi_att_intr_port_attr_store,
1769 };
1770
1771 static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1772         .ct_item_ops            = &target_stat_scsi_att_intr_port_attrib_ops,
1773         .ct_attrs               = target_stat_scsi_ath_intr_port_attrs,
1774         .ct_owner               = THIS_MODULE,
1775 };
1776
1777 /*
1778  * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1779  * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1780  */
1781 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1782 {
1783         struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1784
1785         config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1786                         "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1787         config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1788                         "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1789
1790         ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1791         ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1792         ml_stat_grp->default_groups[2] = NULL;
1793 }