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