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         struct config_group *dev_stat_grp = &dev->dev_stat_grps.stat_group;
 411
 412         config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
 413                         "scsi_dev", &target_stat_scsi_dev_cit);
 414         config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
 415                         "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 416         config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
 417                         "scsi_lu", &target_stat_scsi_lu_cit);
 418
 419         dev_stat_grp->default_groups[0] = &dev->dev_stat_grps.scsi_dev_group;
 420         dev_stat_grp->default_groups[1] = &dev->dev_stat_grps.scsi_tgt_dev_group;
 421         dev_stat_grp->default_groups[2] = &dev->dev_stat_grps.scsi_lu_group;
 422         dev_stat_grp->default_groups[3] = NULL;
 423 }
 424
 425 /*
 426  * SCSI Port Table
 427  */
 428
 429 static struct se_lun *to_stat_port(struct config_item *item)
 430 {
 431         struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 432                         struct se_port_stat_grps, scsi_port_group);
 433         return container_of(pgrps, struct se_lun, port_stat_grps);
 434 }
 435
 436 static ssize_t target_stat_port_inst_show(struct config_item *item, char *page)
 437 {
 438         struct se_lun *lun = to_stat_port(item);
 439         struct se_device *dev;
 440         ssize_t ret = -ENODEV;
 441
 442         rcu_read_lock();
 443         dev = rcu_dereference(lun->lun_se_dev);
 444         if (dev)
 445                 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 446         rcu_read_unlock();
 447         return ret;
 448 }
 449
 450 static ssize_t target_stat_port_dev_show(struct config_item *item, char *page)
 451 {
 452         struct se_lun *lun = to_stat_port(item);
 453         struct se_device *dev;
 454         ssize_t ret = -ENODEV;
 455
 456         rcu_read_lock();
 457         dev = rcu_dereference(lun->lun_se_dev);
 458         if (dev)
 459                 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 460         rcu_read_unlock();
 461         return ret;
 462 }
 463
 464 static ssize_t target_stat_port_indx_show(struct config_item *item, char *page)
 465 {
 466         struct se_lun *lun = to_stat_port(item);
 467         struct se_device *dev;
 468         ssize_t ret = -ENODEV;
 469
 470         rcu_read_lock();
 471         dev = rcu_dereference(lun->lun_se_dev);
 472         if (dev)
 473                 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
 474         rcu_read_unlock();
 475         return ret;
 476 }
 477
 478 static ssize_t target_stat_port_role_show(struct config_item *item, char *page)
 479 {
 480         struct se_lun *lun = to_stat_port(item);
 481         struct se_device *dev;
 482         ssize_t ret = -ENODEV;
 483
 484         rcu_read_lock();
 485         dev = rcu_dereference(lun->lun_se_dev);
 486         if (dev)
 487                 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 488         rcu_read_unlock();
 489         return ret;
 490 }
 491
 492 static ssize_t target_stat_port_busy_count_show(struct config_item *item,
 493                 char *page)
 494 {
 495         struct se_lun *lun = to_stat_port(item);
 496         struct se_device *dev;
 497         ssize_t ret = -ENODEV;
 498
 499         rcu_read_lock();
 500         dev = rcu_dereference(lun->lun_se_dev);
 501         if (dev) {
 502                 /* FIXME: scsiPortBusyStatuses  */
 503                 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 504         }
 505         rcu_read_unlock();
 506         return ret;
 507 }
 508
 509 CONFIGFS_ATTR_RO(target_stat_port_, inst);
 510 CONFIGFS_ATTR_RO(target_stat_port_, dev);
 511 CONFIGFS_ATTR_RO(target_stat_port_, indx);
 512 CONFIGFS_ATTR_RO(target_stat_port_, role);
 513 CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
 514
 515 static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 516         &target_stat_port_attr_inst,
 517         &target_stat_port_attr_dev,
 518         &target_stat_port_attr_indx,
 519         &target_stat_port_attr_role,
 520         &target_stat_port_attr_busy_count,
 521         NULL,
 522 };
 523
 524 static struct config_item_type target_stat_scsi_port_cit = {
 525         .ct_attrs               = target_stat_scsi_port_attrs,
 526         .ct_owner               = THIS_MODULE,
 527 };
 528
 529 /*
 530  * SCSI Target Port Table
 531  */
 532 static struct se_lun *to_stat_tgt_port(struct config_item *item)
 533 {
 534         struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 535                         struct se_port_stat_grps, scsi_tgt_port_group);
 536         return container_of(pgrps, struct se_lun, port_stat_grps);
 537 }
 538
 539 static ssize_t target_stat_tgt_port_inst_show(struct config_item *item,
 540                 char *page)
 541 {
 542         struct se_lun *lun = to_stat_tgt_port(item);
 543         struct se_device *dev;
 544         ssize_t ret = -ENODEV;
 545
 546         rcu_read_lock();
 547         dev = rcu_dereference(lun->lun_se_dev);
 548         if (dev)
 549                 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 550         rcu_read_unlock();
 551         return ret;
 552 }
 553
 554 static ssize_t target_stat_tgt_port_dev_show(struct config_item *item,
 555                 char *page)
 556 {
 557         struct se_lun *lun = to_stat_tgt_port(item);
 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
 569 static ssize_t target_stat_tgt_port_indx_show(struct config_item *item,
 570                 char *page)
 571 {
 572         struct se_lun *lun = to_stat_tgt_port(item);
 573         struct se_device *dev;
 574         ssize_t ret = -ENODEV;
 575
 576         rcu_read_lock();
 577         dev = rcu_dereference(lun->lun_se_dev);
 578         if (dev)
 579                 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
 580         rcu_read_unlock();
 581         return ret;
 582 }
 583
 584 static ssize_t target_stat_tgt_port_name_show(struct config_item *item,
 585                 char *page)
 586 {
 587         struct se_lun *lun = to_stat_tgt_port(item);
 588         struct se_portal_group *tpg = lun->lun_tpg;
 589         struct se_device *dev;
 590         ssize_t ret = -ENODEV;
 591
 592         rcu_read_lock();
 593         dev = rcu_dereference(lun->lun_se_dev);
 594         if (dev)
 595                 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 596                         tpg->se_tpg_tfo->get_fabric_name(),
 597                         lun->lun_rtpi);
 598         rcu_read_unlock();
 599         return ret;
 600 }
 601
 602 static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item,
 603                 char *page)
 604 {
 605         struct se_lun *lun = to_stat_tgt_port(item);
 606         struct se_portal_group *tpg = lun->lun_tpg;
 607         struct se_device *dev;
 608         ssize_t ret = -ENODEV;
 609
 610         rcu_read_lock();
 611         dev = rcu_dereference(lun->lun_se_dev);
 612         if (dev)
 613                 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 614                         tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 615                         tpg->se_tpg_tfo->tpg_get_tag(tpg));
 616         rcu_read_unlock();
 617         return ret;
 618 }
 619
 620 static ssize_t target_stat_tgt_port_in_cmds_show(struct config_item *item,
 621                 char *page)
 622 {
 623         struct se_lun *lun = to_stat_tgt_port(item);
 624         struct se_device *dev;
 625         ssize_t ret = -ENODEV;
 626
 627         rcu_read_lock();
 628         dev = rcu_dereference(lun->lun_se_dev);
 629         if (dev)
 630                 ret = snprintf(page, PAGE_SIZE, "%lu\n",
 631                                atomic_long_read(&lun->lun_stats.cmd_pdus));
 632         rcu_read_unlock();
 633         return ret;
 634 }
 635
 636 static ssize_t target_stat_tgt_port_write_mbytes_show(struct config_item *item,
 637                 char *page)
 638 {
 639         struct se_lun *lun = to_stat_tgt_port(item);
 640         struct se_device *dev;
 641         ssize_t ret = -ENODEV;
 642
 643         rcu_read_lock();
 644         dev = rcu_dereference(lun->lun_se_dev);
 645         if (dev)
 646                 ret = snprintf(page, PAGE_SIZE, "%u\n",
 647                         (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
 648         rcu_read_unlock();
 649         return ret;
 650 }
 651
 652 static ssize_t target_stat_tgt_port_read_mbytes_show(struct config_item *item,
 653                 char *page)
 654 {
 655         struct se_lun *lun = to_stat_tgt_port(item);
 656         struct se_device *dev;
 657         ssize_t ret = -ENODEV;
 658
 659         rcu_read_lock();
 660         dev = rcu_dereference(lun->lun_se_dev);
 661         if (dev)
 662                 ret = snprintf(page, PAGE_SIZE, "%u\n",
 663                                 (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
 664         rcu_read_unlock();
 665         return ret;
 666 }
 667
 668 static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item,
 669                 char *page)
 670 {
 671         struct se_lun *lun = to_stat_tgt_port(item);
 672         struct se_device *dev;
 673         ssize_t ret = -ENODEV;
 674
 675         rcu_read_lock();
 676         dev = rcu_dereference(lun->lun_se_dev);
 677         if (dev) {
 678                 /* FIXME: scsiTgtPortHsInCommands */
 679                 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 680         }
 681         rcu_read_unlock();
 682         return ret;
 683 }
 684
 685 CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
 686 CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
 687 CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
 688 CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
 689 CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
 690 CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
 691 CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
 692 CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
 693 CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
 694
 695 static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
 696         &target_stat_tgt_port_attr_inst,
 697         &target_stat_tgt_port_attr_dev,
 698         &target_stat_tgt_port_attr_indx,
 699         &target_stat_tgt_port_attr_name,
 700         &target_stat_tgt_port_attr_port_index,
 701         &target_stat_tgt_port_attr_in_cmds,
 702         &target_stat_tgt_port_attr_write_mbytes,
 703         &target_stat_tgt_port_attr_read_mbytes,
 704         &target_stat_tgt_port_attr_hs_in_cmds,
 705         NULL,
 706 };
 707
 708 static struct config_item_type target_stat_scsi_tgt_port_cit = {
 709         .ct_attrs               = target_stat_scsi_tgt_port_attrs,
 710         .ct_owner               = THIS_MODULE,
 711 };
 712
 713 /*
 714  * SCSI Transport Table
 715  */
 716 static struct se_lun *to_transport_stat(struct config_item *item)
 717 {
 718         struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 719                         struct se_port_stat_grps, scsi_transport_group);
 720         return container_of(pgrps, struct se_lun, port_stat_grps);
 721 }
 722
 723 static ssize_t target_stat_transport_inst_show(struct config_item *item,
 724                 char *page)
 725 {
 726         struct se_lun *lun = to_transport_stat(item);
 727         struct se_device *dev;
 728         ssize_t ret = -ENODEV;
 729
 730         rcu_read_lock();
 731         dev = rcu_dereference(lun->lun_se_dev);
 732         if (dev)
 733                 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 734         rcu_read_unlock();
 735         return ret;
 736 }
 737
 738 static ssize_t target_stat_transport_device_show(struct config_item *item,
 739                 char *page)
 740 {
 741         struct se_lun *lun = to_transport_stat(item);
 742         struct se_device *dev;
 743         struct se_portal_group *tpg = lun->lun_tpg;
 744         ssize_t ret = -ENODEV;
 745
 746         rcu_read_lock();
 747         dev = rcu_dereference(lun->lun_se_dev);
 748         if (dev) {
 749                 /* scsiTransportType */
 750                 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
 751                                tpg->se_tpg_tfo->get_fabric_name());
 752         }
 753         rcu_read_unlock();
 754         return ret;
 755 }
 756
 757 static ssize_t target_stat_transport_indx_show(struct config_item *item,
 758                 char *page)
 759 {
 760         struct se_lun *lun = to_transport_stat(item);
 761         struct se_device *dev;
 762         struct se_portal_group *tpg = lun->lun_tpg;
 763         ssize_t ret = -ENODEV;
 764
 765         rcu_read_lock();
 766         dev = rcu_dereference(lun->lun_se_dev);
 767         if (dev)
 768                 ret = snprintf(page, PAGE_SIZE, "%u\n",
 769                                tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 770         rcu_read_unlock();
 771         return ret;
 772 }
 773
 774 static ssize_t target_stat_transport_dev_name_show(struct config_item *item,
 775                 char *page)
 776 {
 777         struct se_lun *lun = to_transport_stat(item);
 778         struct se_device *dev;
 779         struct se_portal_group *tpg = lun->lun_tpg;
 780         struct t10_wwn *wwn;
 781         ssize_t ret = -ENODEV;
 782
 783         rcu_read_lock();
 784         dev = rcu_dereference(lun->lun_se_dev);
 785         if (dev) {
 786                 wwn = &dev->t10_wwn;
 787                 /* scsiTransportDevName */
 788                 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
 789                                 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
 790                                 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
 791                                 wwn->vendor);
 792         }
 793         rcu_read_unlock();
 794         return ret;
 795 }
 796
 797 CONFIGFS_ATTR_RO(target_stat_transport_, inst);
 798 CONFIGFS_ATTR_RO(target_stat_transport_, device);
 799 CONFIGFS_ATTR_RO(target_stat_transport_, indx);
 800 CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
 801
 802 static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
 803         &target_stat_transport_attr_inst,
 804         &target_stat_transport_attr_device,
 805         &target_stat_transport_attr_indx,
 806         &target_stat_transport_attr_dev_name,
 807         NULL,
 808 };
 809
 810 static struct config_item_type target_stat_scsi_transport_cit = {
 811         .ct_attrs               = target_stat_scsi_transport_attrs,
 812         .ct_owner               = THIS_MODULE,
 813 };
 814
 815 /*
 816  * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
 817  * the target port statistics groups + configfs CITs located in target_core_stat.c
 818  */
 819 void target_stat_setup_port_default_groups(struct se_lun *lun)
 820 {
 821         struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
 822
 823         config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
 824                         "scsi_port", &target_stat_scsi_port_cit);
 825         config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
 826                         "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
 827         config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
 828                         "scsi_transport", &target_stat_scsi_transport_cit);
 829
 830         port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
 831         port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
 832         port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
 833         port_stat_grp->default_groups[3] = NULL;
 834 }
 835
 836 /*
 837  * SCSI Authorized Initiator Table
 838  */
 839
 840 static struct se_lun_acl *auth_to_lacl(struct config_item *item)
 841 {
 842         struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
 843                         struct se_ml_stat_grps, scsi_auth_intr_group);
 844         return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
 845 }
 846
 847 static ssize_t target_stat_auth_inst_show(struct config_item *item,
 848                 char *page)
 849 {
 850         struct se_lun_acl *lacl = auth_to_lacl(item);
 851         struct se_node_acl *nacl = lacl->se_lun_nacl;
 852         struct se_dev_entry *deve;
 853         struct se_portal_group *tpg;
 854         ssize_t ret;
 855
 856         rcu_read_lock();
 857         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 858         if (!deve) {
 859                 rcu_read_unlock();
 860                 return -ENODEV;
 861         }
 862         tpg = nacl->se_tpg;
 863         /* scsiInstIndex */
 864         ret = snprintf(page, PAGE_SIZE, "%u\n",
 865                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 866         rcu_read_unlock();
 867         return ret;
 868 }
 869
 870 static ssize_t target_stat_auth_dev_show(struct config_item *item,
 871                 char *page)
 872 {
 873         struct se_lun_acl *lacl = auth_to_lacl(item);
 874         struct se_node_acl *nacl = lacl->se_lun_nacl;
 875         struct se_dev_entry *deve;
 876         struct se_lun *lun;
 877         ssize_t ret;
 878
 879         rcu_read_lock();
 880         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 881         if (!deve) {
 882                 rcu_read_unlock();
 883                 return -ENODEV;
 884         }
 885         lun = rcu_dereference(deve->se_lun);
 886         /* scsiDeviceIndex */
 887         ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
 888         rcu_read_unlock();
 889         return ret;
 890 }
 891
 892 static ssize_t target_stat_auth_port_show(struct config_item *item,
 893                 char *page)
 894 {
 895         struct se_lun_acl *lacl = auth_to_lacl(item);
 896         struct se_node_acl *nacl = lacl->se_lun_nacl;
 897         struct se_dev_entry *deve;
 898         struct se_portal_group *tpg;
 899         ssize_t ret;
 900
 901         rcu_read_lock();
 902         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 903         if (!deve) {
 904                 rcu_read_unlock();
 905                 return -ENODEV;
 906         }
 907         tpg = nacl->se_tpg;
 908         /* scsiAuthIntrTgtPortIndex */
 909         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
 910         rcu_read_unlock();
 911         return ret;
 912 }
 913
 914 static ssize_t target_stat_auth_indx_show(struct config_item *item,
 915                 char *page)
 916 {
 917         struct se_lun_acl *lacl = auth_to_lacl(item);
 918         struct se_node_acl *nacl = lacl->se_lun_nacl;
 919         struct se_dev_entry *deve;
 920         ssize_t ret;
 921
 922         rcu_read_lock();
 923         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 924         if (!deve) {
 925                 rcu_read_unlock();
 926                 return -ENODEV;
 927         }
 928         /* scsiAuthIntrIndex */
 929         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
 930         rcu_read_unlock();
 931         return ret;
 932 }
 933
 934 static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
 935                 char *page)
 936 {
 937         struct se_lun_acl *lacl = auth_to_lacl(item);
 938         struct se_node_acl *nacl = lacl->se_lun_nacl;
 939         struct se_dev_entry *deve;
 940         ssize_t ret;
 941
 942         rcu_read_lock();
 943         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 944         if (!deve) {
 945                 rcu_read_unlock();
 946                 return -ENODEV;
 947         }
 948         /* scsiAuthIntrDevOrPort */
 949         ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
 950         rcu_read_unlock();
 951         return ret;
 952 }
 953
 954 static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
 955                 char *page)
 956 {
 957         struct se_lun_acl *lacl = auth_to_lacl(item);
 958         struct se_node_acl *nacl = lacl->se_lun_nacl;
 959         struct se_dev_entry *deve;
 960         ssize_t ret;
 961
 962         rcu_read_lock();
 963         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 964         if (!deve) {
 965                 rcu_read_unlock();
 966                 return -ENODEV;
 967         }
 968         /* scsiAuthIntrName */
 969         ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
 970         rcu_read_unlock();
 971         return ret;
 972 }
 973
 974 static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
 975                 char *page)
 976 {
 977         struct se_lun_acl *lacl = auth_to_lacl(item);
 978         struct se_node_acl *nacl = lacl->se_lun_nacl;
 979         struct se_dev_entry *deve;
 980         ssize_t ret;
 981
 982         rcu_read_lock();
 983         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 984         if (!deve) {
 985                 rcu_read_unlock();
 986                 return -ENODEV;
 987         }
 988         /* FIXME: scsiAuthIntrLunMapIndex */
 989         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 990         rcu_read_unlock();
 991         return ret;
 992 }
 993
 994 static ssize_t target_stat_auth_att_count_show(struct config_item *item,
 995                 char *page)
 996 {
 997         struct se_lun_acl *lacl = auth_to_lacl(item);
 998         struct se_node_acl *nacl = lacl->se_lun_nacl;
 999         struct se_dev_entry *deve;
1000         ssize_t ret;
1001
1002         rcu_read_lock();
1003         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1004         if (!deve) {
1005                 rcu_read_unlock();
1006                 return -ENODEV;
1007         }
1008         /* scsiAuthIntrAttachedTimes */
1009         ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1010         rcu_read_unlock();
1011         return ret;
1012 }
1013
1014 static ssize_t target_stat_auth_num_cmds_show(struct config_item *item,
1015                 char *page)
1016 {
1017         struct se_lun_acl *lacl = auth_to_lacl(item);
1018         struct se_node_acl *nacl = lacl->se_lun_nacl;
1019         struct se_dev_entry *deve;
1020         ssize_t ret;
1021
1022         rcu_read_lock();
1023         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1024         if (!deve) {
1025                 rcu_read_unlock();
1026                 return -ENODEV;
1027         }
1028         /* scsiAuthIntrOutCommands */
1029         ret = snprintf(page, PAGE_SIZE, "%lu\n",
1030                        atomic_long_read(&deve->total_cmds));
1031         rcu_read_unlock();
1032         return ret;
1033 }
1034
1035 static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item,
1036                 char *page)
1037 {
1038         struct se_lun_acl *lacl = auth_to_lacl(item);
1039         struct se_node_acl *nacl = lacl->se_lun_nacl;
1040         struct se_dev_entry *deve;
1041         ssize_t ret;
1042
1043         rcu_read_lock();
1044         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1045         if (!deve) {
1046                 rcu_read_unlock();
1047                 return -ENODEV;
1048         }
1049         /* scsiAuthIntrReadMegaBytes */
1050         ret = snprintf(page, PAGE_SIZE, "%u\n",
1051                       (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1052         rcu_read_unlock();
1053         return ret;
1054 }
1055
1056 static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item,
1057                 char *page)
1058 {
1059         struct se_lun_acl *lacl = auth_to_lacl(item);
1060         struct se_node_acl *nacl = lacl->se_lun_nacl;
1061         struct se_dev_entry *deve;
1062         ssize_t ret;
1063
1064         rcu_read_lock();
1065         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1066         if (!deve) {
1067                 rcu_read_unlock();
1068                 return -ENODEV;
1069         }
1070         /* scsiAuthIntrWrittenMegaBytes */
1071         ret = snprintf(page, PAGE_SIZE, "%u\n",
1072                       (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1073         rcu_read_unlock();
1074         return ret;
1075 }
1076
1077 static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1078                 char *page)
1079 {
1080         struct se_lun_acl *lacl = auth_to_lacl(item);
1081         struct se_node_acl *nacl = lacl->se_lun_nacl;
1082         struct se_dev_entry *deve;
1083         ssize_t ret;
1084
1085         rcu_read_lock();
1086         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1087         if (!deve) {
1088                 rcu_read_unlock();
1089                 return -ENODEV;
1090         }
1091         /* FIXME: scsiAuthIntrHSOutCommands */
1092         ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1093         rcu_read_unlock();
1094         return ret;
1095 }
1096
1097 static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1098                 char *page)
1099 {
1100         struct se_lun_acl *lacl = auth_to_lacl(item);
1101         struct se_node_acl *nacl = lacl->se_lun_nacl;
1102         struct se_dev_entry *deve;
1103         ssize_t ret;
1104
1105         rcu_read_lock();
1106         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1107         if (!deve) {
1108                 rcu_read_unlock();
1109                 return -ENODEV;
1110         }
1111         /* scsiAuthIntrLastCreation */
1112         ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1113                                 INITIAL_JIFFIES) * 100 / HZ));
1114         rcu_read_unlock();
1115         return ret;
1116 }
1117
1118 static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1119                 char *page)
1120 {
1121         struct se_lun_acl *lacl = auth_to_lacl(item);
1122         struct se_node_acl *nacl = lacl->se_lun_nacl;
1123         struct se_dev_entry *deve;
1124         ssize_t ret;
1125
1126         rcu_read_lock();
1127         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1128         if (!deve) {
1129                 rcu_read_unlock();
1130                 return -ENODEV;
1131         }
1132         /* FIXME: scsiAuthIntrRowStatus */
1133         ret = snprintf(page, PAGE_SIZE, "Ready\n");
1134         rcu_read_unlock();
1135         return ret;
1136 }
1137
1138 CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1139 CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1140 CONFIGFS_ATTR_RO(target_stat_auth_, port);
1141 CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1142 CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1143 CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1144 CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1145 CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1146 CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1147 CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1148 CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1149 CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1150 CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1151 CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1152
1153 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1154         &target_stat_auth_attr_inst,
1155         &target_stat_auth_attr_dev,
1156         &target_stat_auth_attr_port,
1157         &target_stat_auth_attr_indx,
1158         &target_stat_auth_attr_dev_or_port,
1159         &target_stat_auth_attr_intr_name,
1160         &target_stat_auth_attr_map_indx,
1161         &target_stat_auth_attr_att_count,
1162         &target_stat_auth_attr_num_cmds,
1163         &target_stat_auth_attr_read_mbytes,
1164         &target_stat_auth_attr_write_mbytes,
1165         &target_stat_auth_attr_hs_num_cmds,
1166         &target_stat_auth_attr_creation_time,
1167         &target_stat_auth_attr_row_status,
1168         NULL,
1169 };
1170
1171 static struct config_item_type target_stat_scsi_auth_intr_cit = {
1172         .ct_attrs               = target_stat_scsi_auth_intr_attrs,
1173         .ct_owner               = THIS_MODULE,
1174 };
1175
1176 /*
1177  * SCSI Attached Initiator Port Table
1178  */
1179
1180 static struct se_lun_acl *iport_to_lacl(struct config_item *item)
1181 {
1182         struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1183                         struct se_ml_stat_grps, scsi_att_intr_port_group);
1184         return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1185 }
1186
1187 static ssize_t target_stat_iport_inst_show(struct config_item *item,
1188                 char *page)
1189 {
1190         struct se_lun_acl *lacl = iport_to_lacl(item);
1191         struct se_node_acl *nacl = lacl->se_lun_nacl;
1192         struct se_dev_entry *deve;
1193         struct se_portal_group *tpg;
1194         ssize_t ret;
1195
1196         rcu_read_lock();
1197         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1198         if (!deve) {
1199                 rcu_read_unlock();
1200                 return -ENODEV;
1201         }
1202         tpg = nacl->se_tpg;
1203         /* scsiInstIndex */
1204         ret = snprintf(page, PAGE_SIZE, "%u\n",
1205                         tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1206         rcu_read_unlock();
1207         return ret;
1208 }
1209
1210 static ssize_t target_stat_iport_dev_show(struct config_item *item,
1211                 char *page)
1212 {
1213         struct se_lun_acl *lacl = iport_to_lacl(item);
1214         struct se_node_acl *nacl = lacl->se_lun_nacl;
1215         struct se_dev_entry *deve;
1216         struct se_lun *lun;
1217         ssize_t ret;
1218
1219         rcu_read_lock();
1220         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1221         if (!deve) {
1222                 rcu_read_unlock();
1223                 return -ENODEV;
1224         }
1225         lun = rcu_dereference(deve->se_lun);
1226         /* scsiDeviceIndex */
1227         ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1228         rcu_read_unlock();
1229         return ret;
1230 }
1231
1232 static ssize_t target_stat_iport_port_show(struct config_item *item,
1233                 char *page)
1234 {
1235         struct se_lun_acl *lacl = iport_to_lacl(item);
1236         struct se_node_acl *nacl = lacl->se_lun_nacl;
1237         struct se_dev_entry *deve;
1238         struct se_portal_group *tpg;
1239         ssize_t ret;
1240
1241         rcu_read_lock();
1242         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1243         if (!deve) {
1244                 rcu_read_unlock();
1245                 return -ENODEV;
1246         }
1247         tpg = nacl->se_tpg;
1248         /* scsiPortIndex */
1249         ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1250         rcu_read_unlock();
1251         return ret;
1252 }
1253
1254 static ssize_t target_stat_iport_indx_show(struct config_item *item,
1255                 char *page)
1256 {
1257         struct se_lun_acl *lacl = iport_to_lacl(item);
1258         struct se_node_acl *nacl = lacl->se_lun_nacl;
1259         struct se_session *se_sess;
1260         struct se_portal_group *tpg;
1261         ssize_t ret;
1262
1263         spin_lock_irq(&nacl->nacl_sess_lock);
1264         se_sess = nacl->nacl_sess;
1265         if (!se_sess) {
1266                 spin_unlock_irq(&nacl->nacl_sess_lock);
1267                 return -ENODEV;
1268         }
1269
1270         tpg = nacl->se_tpg;
1271         /* scsiAttIntrPortIndex */
1272         ret = snprintf(page, PAGE_SIZE, "%u\n",
1273                         tpg->se_tpg_tfo->sess_get_index(se_sess));
1274         spin_unlock_irq(&nacl->nacl_sess_lock);
1275         return ret;
1276 }
1277
1278 static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item,
1279                 char *page)
1280 {
1281         struct se_lun_acl *lacl = iport_to_lacl(item);
1282         struct se_node_acl *nacl = lacl->se_lun_nacl;
1283         struct se_dev_entry *deve;
1284         ssize_t ret;
1285
1286         rcu_read_lock();
1287         deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1288         if (!deve) {
1289                 rcu_read_unlock();
1290                 return -ENODEV;
1291         }
1292         /* scsiAttIntrPortAuthIntrIdx */
1293         ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1294         rcu_read_unlock();
1295         return ret;
1296 }
1297
1298 static ssize_t target_stat_iport_port_ident_show(struct config_item *item,
1299                 char *page)
1300 {
1301         struct se_lun_acl *lacl = iport_to_lacl(item);
1302         struct se_node_acl *nacl = lacl->se_lun_nacl;
1303         struct se_session *se_sess;
1304         struct se_portal_group *tpg;
1305         ssize_t ret;
1306         unsigned char buf[64];
1307
1308         spin_lock_irq(&nacl->nacl_sess_lock);
1309         se_sess = nacl->nacl_sess;
1310         if (!se_sess) {
1311                 spin_unlock_irq(&nacl->nacl_sess_lock);
1312                 return -ENODEV;
1313         }
1314
1315         tpg = nacl->se_tpg;
1316         /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1317         memset(buf, 0, 64);
1318         if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1319                 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1320
1321         ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1322         spin_unlock_irq(&nacl->nacl_sess_lock);
1323         return ret;
1324 }
1325
1326 CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1327 CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1328 CONFIGFS_ATTR_RO(target_stat_iport_, port);
1329 CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1330 CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1331 CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
1332
1333 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1334         &target_stat_iport_attr_inst,
1335         &target_stat_iport_attr_dev,
1336         &target_stat_iport_attr_port,
1337         &target_stat_iport_attr_indx,
1338         &target_stat_iport_attr_port_auth_indx,
1339         &target_stat_iport_attr_port_ident,
1340         NULL,
1341 };
1342
1343 static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1344         .ct_attrs               = target_stat_scsi_ath_intr_port_attrs,
1345         .ct_owner               = THIS_MODULE,
1346 };
1347
1348 /*
1349  * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1350  * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1351  */
1352 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1353 {
1354         struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
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         config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1359                         "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1360
1361         ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1362         ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1363         ml_stat_grp->default_groups[2] = NULL;
1364 }