drivers/target/target_core_stat.c

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