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