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