target_core_stat.c

   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\n");
 121	else
 122		return snprintf(page, PAGE_SIZE, "deactivated\n");
 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
 279#define per_cpu_stat_snprintf(stats_struct, prefix, field, shift)	\
 280static ssize_t								\
 281per_cpu_stat_##prefix##_snprintf(struct stats_struct __percpu *per_cpu_stats, \
 282				 char *page)				\
 283{									\
 284	struct stats_struct *stats;					\
 285	unsigned int cpu;						\
 286	u64 sum = 0;							\
 287									\
 288	for_each_possible_cpu(cpu) {					\
 289		stats = per_cpu_ptr(per_cpu_stats, cpu);		\
 290		sum += stats->field;					\
 291	}								\
 292									\
 293	return snprintf(page, PAGE_SIZE, "%llu\n", sum >> shift);	\
 294}
 295
 296#define lu_show_per_cpu_stat(prefix, field, shift)			\
 297per_cpu_stat_snprintf(se_dev_io_stats, prefix, field, shift);		\
 298static ssize_t								\
 299target_stat_##prefix##_show(struct config_item *item, char *page)	\
 300{									\
 301	struct se_device *dev = to_stat_lu_dev(item);			\
 302									\
 303	return per_cpu_stat_##prefix##_snprintf(dev->stats, page);	\
 304}									\
 305
 306/* scsiLuNumCommands */
 307lu_show_per_cpu_stat(lu_num_cmds, total_cmds, 0);
 308/* scsiLuReadMegaBytes */
 309lu_show_per_cpu_stat(lu_read_mbytes, read_bytes, 20);
 310/* scsiLuWrittenMegaBytes */
 311lu_show_per_cpu_stat(lu_write_mbytes, write_bytes, 20);
 312
 313static ssize_t target_stat_lu_resets_show(struct config_item *item, char *page)
 314{
 315	struct se_device *dev = to_stat_lu_dev(item);
 316
 317	/* scsiLuInResets */
 318	return snprintf(page, PAGE_SIZE, "%lu\n",
 319		atomic_long_read(&dev->num_resets));
 320}
 321
 322static ssize_t target_stat_lu_full_stat_show(struct config_item *item,
 323		char *page)
 324{
 325	/* FIXME: scsiLuOutTaskSetFullStatus */
 326	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 327}
 328
 329static ssize_t target_stat_lu_hs_num_cmds_show(struct config_item *item,
 330		char *page)
 331{
 332	/* FIXME: scsiLuHSInCommands */
 333	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 334}
 335
 336static ssize_t target_stat_lu_creation_time_show(struct config_item *item,
 337		char *page)
 338{
 339	struct se_device *dev = to_stat_lu_dev(item);
 340
 341	/* scsiLuCreationTime */
 342	return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
 343				INITIAL_JIFFIES) * 100 / HZ));
 344}
 345
 346CONFIGFS_ATTR_RO(target_stat_lu_, inst);
 347CONFIGFS_ATTR_RO(target_stat_lu_, dev);
 348CONFIGFS_ATTR_RO(target_stat_lu_, indx);
 349CONFIGFS_ATTR_RO(target_stat_lu_, lun);
 350CONFIGFS_ATTR_RO(target_stat_lu_, lu_name);
 351CONFIGFS_ATTR_RO(target_stat_lu_, vend);
 352CONFIGFS_ATTR_RO(target_stat_lu_, prod);
 353CONFIGFS_ATTR_RO(target_stat_lu_, rev);
 354CONFIGFS_ATTR_RO(target_stat_lu_, dev_type);
 355CONFIGFS_ATTR_RO(target_stat_lu_, status);
 356CONFIGFS_ATTR_RO(target_stat_lu_, state_bit);
 357CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds);
 358CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes);
 359CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes);
 360CONFIGFS_ATTR_RO(target_stat_lu_, resets);
 361CONFIGFS_ATTR_RO(target_stat_lu_, full_stat);
 362CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds);
 363CONFIGFS_ATTR_RO(target_stat_lu_, creation_time);
 364
 365static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
 366	&target_stat_lu_attr_inst,
 367	&target_stat_lu_attr_dev,
 368	&target_stat_lu_attr_indx,
 369	&target_stat_lu_attr_lun,
 370	&target_stat_lu_attr_lu_name,
 371	&target_stat_lu_attr_vend,
 372	&target_stat_lu_attr_prod,
 373	&target_stat_lu_attr_rev,
 374	&target_stat_lu_attr_dev_type,
 375	&target_stat_lu_attr_status,
 376	&target_stat_lu_attr_state_bit,
 377	&target_stat_lu_attr_num_cmds,
 378	&target_stat_lu_attr_read_mbytes,
 379	&target_stat_lu_attr_write_mbytes,
 380	&target_stat_lu_attr_resets,
 381	&target_stat_lu_attr_full_stat,
 382	&target_stat_lu_attr_hs_num_cmds,
 383	&target_stat_lu_attr_creation_time,
 384	NULL,
 385};
 386
 387static const struct config_item_type target_stat_scsi_lu_cit = {
 388	.ct_attrs		= target_stat_scsi_lu_attrs,
 389	.ct_owner		= THIS_MODULE,
 390};
 391
 392/*
 393 * Called from target_core_configfs.c:target_core_make_subdev() to setup
 394 * the target statistics groups + configfs CITs located in target_core_stat.c
 395 */
 396void target_stat_setup_dev_default_groups(struct se_device *dev)
 397{
 398	config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
 399			"scsi_dev", &target_stat_scsi_dev_cit);
 400	configfs_add_default_group(&dev->dev_stat_grps.scsi_dev_group,
 401			&dev->dev_stat_grps.stat_group);
 402
 403	config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
 404			"scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 405	configfs_add_default_group(&dev->dev_stat_grps.scsi_tgt_dev_group,
 406			&dev->dev_stat_grps.stat_group);
 407
 408	config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
 409			"scsi_lu", &target_stat_scsi_lu_cit);
 410	configfs_add_default_group(&dev->dev_stat_grps.scsi_lu_group,
 411			&dev->dev_stat_grps.stat_group);
 412}
 413
 414/*
 415 * SCSI Port Table
 416 */
 417
 418static struct se_lun *to_stat_port(struct config_item *item)
 419{
 420	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 421			struct se_port_stat_grps, scsi_port_group);
 422	return container_of(pgrps, struct se_lun, port_stat_grps);
 423}
 424
 425static ssize_t target_stat_port_inst_show(struct config_item *item, char *page)
 426{
 427	struct se_lun *lun = to_stat_port(item);
 428	struct se_device *dev;
 429	ssize_t ret = -ENODEV;
 430
 431	rcu_read_lock();
 432	dev = rcu_dereference(lun->lun_se_dev);
 433	if (dev)
 434		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 435	rcu_read_unlock();
 436	return ret;
 437}
 438
 439static ssize_t target_stat_port_dev_show(struct config_item *item, char *page)
 440{
 441	struct se_lun *lun = to_stat_port(item);
 442	struct se_device *dev;
 443	ssize_t ret = -ENODEV;
 444
 445	rcu_read_lock();
 446	dev = rcu_dereference(lun->lun_se_dev);
 447	if (dev)
 448		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 449	rcu_read_unlock();
 450	return ret;
 451}
 452
 453static ssize_t target_stat_port_indx_show(struct config_item *item, char *page)
 454{
 455	struct se_lun *lun = to_stat_port(item);
 456	struct se_device *dev;
 457	ssize_t ret = -ENODEV;
 458
 459	rcu_read_lock();
 460	dev = rcu_dereference(lun->lun_se_dev);
 461	if (dev)
 462		ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_tpg->tpg_rtpi);
 463	rcu_read_unlock();
 464	return ret;
 465}
 466
 467static ssize_t target_stat_port_role_show(struct config_item *item, char *page)
 468{
 469	struct se_lun *lun = to_stat_port(item);
 470	struct se_device *dev;
 471	ssize_t ret = -ENODEV;
 472
 473	rcu_read_lock();
 474	dev = rcu_dereference(lun->lun_se_dev);
 475	if (dev)
 476		ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 477	rcu_read_unlock();
 478	return ret;
 479}
 480
 481static ssize_t target_stat_port_busy_count_show(struct config_item *item,
 482		char *page)
 483{
 484	struct se_lun *lun = to_stat_port(item);
 485	struct se_device *dev;
 486	ssize_t ret = -ENODEV;
 487
 488	rcu_read_lock();
 489	dev = rcu_dereference(lun->lun_se_dev);
 490	if (dev) {
 491		/* FIXME: scsiPortBusyStatuses  */
 492		ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 493	}
 494	rcu_read_unlock();
 495	return ret;
 496}
 497
 498CONFIGFS_ATTR_RO(target_stat_port_, inst);
 499CONFIGFS_ATTR_RO(target_stat_port_, dev);
 500CONFIGFS_ATTR_RO(target_stat_port_, indx);
 501CONFIGFS_ATTR_RO(target_stat_port_, role);
 502CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
 503
 504static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 505	&target_stat_port_attr_inst,
 506	&target_stat_port_attr_dev,
 507	&target_stat_port_attr_indx,
 508	&target_stat_port_attr_role,
 509	&target_stat_port_attr_busy_count,
 510	NULL,
 511};
 512
 513static const struct config_item_type target_stat_scsi_port_cit = {
 514	.ct_attrs		= target_stat_scsi_port_attrs,
 515	.ct_owner		= THIS_MODULE,
 516};
 517
 518/*
 519 * SCSI Target Port Table
 520 */
 521static struct se_lun *to_stat_tgt_port(struct config_item *item)
 522{
 523	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 524			struct se_port_stat_grps, scsi_tgt_port_group);
 525	return container_of(pgrps, struct se_lun, port_stat_grps);
 526}
 527
 528static ssize_t target_stat_tgt_port_inst_show(struct config_item *item,
 529		char *page)
 530{
 531	struct se_lun *lun = to_stat_tgt_port(item);
 532	struct se_device *dev;
 533	ssize_t ret = -ENODEV;
 534
 535	rcu_read_lock();
 536	dev = rcu_dereference(lun->lun_se_dev);
 537	if (dev)
 538		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 539	rcu_read_unlock();
 540	return ret;
 541}
 542
 543static ssize_t target_stat_tgt_port_dev_show(struct config_item *item,
 544		char *page)
 545{
 546	struct se_lun *lun = to_stat_tgt_port(item);
 547	struct se_device *dev;
 548	ssize_t ret = -ENODEV;
 549
 550	rcu_read_lock();
 551	dev = rcu_dereference(lun->lun_se_dev);
 552	if (dev)
 553		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 554	rcu_read_unlock();
 555	return ret;
 556}
 557
 558static ssize_t target_stat_tgt_port_indx_show(struct config_item *item,
 559		char *page)
 560{
 561	struct se_lun *lun = to_stat_tgt_port(item);
 562	struct se_device *dev;
 563	ssize_t ret = -ENODEV;
 564
 565	rcu_read_lock();
 566	dev = rcu_dereference(lun->lun_se_dev);
 567	if (dev)
 568		ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_tpg->tpg_rtpi);
 569	rcu_read_unlock();
 570	return ret;
 571}
 572
 573static ssize_t target_stat_tgt_port_name_show(struct config_item *item,
 574		char *page)
 575{
 576	struct se_lun *lun = to_stat_tgt_port(item);
 577	struct se_portal_group *tpg = lun->lun_tpg;
 578	struct se_device *dev;
 579	ssize_t ret = -ENODEV;
 580
 581	rcu_read_lock();
 582	dev = rcu_dereference(lun->lun_se_dev);
 583	if (dev)
 584		ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 585			tpg->se_tpg_tfo->fabric_name,
 586			lun->lun_tpg->tpg_rtpi);
 587	rcu_read_unlock();
 588	return ret;
 589}
 590
 591static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item,
 592		char *page)
 593{
 594	struct se_lun *lun = to_stat_tgt_port(item);
 595	struct se_portal_group *tpg = lun->lun_tpg;
 596	struct se_device *dev;
 597	ssize_t ret = -ENODEV;
 598
 599	rcu_read_lock();
 600	dev = rcu_dereference(lun->lun_se_dev);
 601	if (dev)
 602		ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 603			tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 604			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 605	rcu_read_unlock();
 606	return ret;
 607}
 608
 609#define tgt_port_show_per_cpu_stat(prefix, field, shift)		\
 610per_cpu_stat_snprintf(scsi_port_stats, prefix, field, shift);		\
 611static ssize_t								\
 612target_stat_##prefix##_show(struct config_item *item, char *page)	\
 613{									\
 614	struct se_lun *lun = to_stat_tgt_port(item);			\
 615	struct se_device *dev;						\
 616	int ret;							\
 617									\
 618	rcu_read_lock();						\
 619	dev = rcu_dereference(lun->lun_se_dev);				\
 620	if (!dev) {							\
 621		rcu_read_unlock();					\
 622		return -ENODEV;						\
 623	}								\
 624									\
 625	ret = per_cpu_stat_##prefix##_snprintf(lun->lun_stats, page);	\
 626	rcu_read_unlock();						\
 627	return ret;							\
 628}
 629
 630tgt_port_show_per_cpu_stat(tgt_port_in_cmds, cmd_pdus, 0);
 631tgt_port_show_per_cpu_stat(tgt_port_write_mbytes, rx_data_octets, 20);
 632tgt_port_show_per_cpu_stat(tgt_port_read_mbytes, tx_data_octets, 20);
 633
 634static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item,
 635		char *page)
 636{
 637	struct se_lun *lun = to_stat_tgt_port(item);
 638	struct se_device *dev;
 639	ssize_t ret = -ENODEV;
 640
 641	rcu_read_lock();
 642	dev = rcu_dereference(lun->lun_se_dev);
 643	if (dev) {
 644		/* FIXME: scsiTgtPortHsInCommands */
 645		ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 646	}
 647	rcu_read_unlock();
 648	return ret;
 649}
 650
 651CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
 652CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
 653CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
 654CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
 655CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
 656CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
 657CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
 658CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
 659CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
 660
 661static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
 662	&target_stat_tgt_port_attr_inst,
 663	&target_stat_tgt_port_attr_dev,
 664	&target_stat_tgt_port_attr_indx,
 665	&target_stat_tgt_port_attr_name,
 666	&target_stat_tgt_port_attr_port_index,
 667	&target_stat_tgt_port_attr_in_cmds,
 668	&target_stat_tgt_port_attr_write_mbytes,
 669	&target_stat_tgt_port_attr_read_mbytes,
 670	&target_stat_tgt_port_attr_hs_in_cmds,
 671	NULL,
 672};
 673
 674static const struct config_item_type target_stat_scsi_tgt_port_cit = {
 675	.ct_attrs		= target_stat_scsi_tgt_port_attrs,
 676	.ct_owner		= THIS_MODULE,
 677};
 678
 679/*
 680 * SCSI Transport Table
 681 */
 682static struct se_lun *to_transport_stat(struct config_item *item)
 683{
 684	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 685			struct se_port_stat_grps, scsi_transport_group);
 686	return container_of(pgrps, struct se_lun, port_stat_grps);
 687}
 688
 689static ssize_t target_stat_transport_inst_show(struct config_item *item,
 690		char *page)
 691{
 692	struct se_lun *lun = to_transport_stat(item);
 693	struct se_device *dev;
 694	ssize_t ret = -ENODEV;
 695
 696	rcu_read_lock();
 697	dev = rcu_dereference(lun->lun_se_dev);
 698	if (dev)
 699		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 700	rcu_read_unlock();
 701	return ret;
 702}
 703
 704static ssize_t target_stat_transport_device_show(struct config_item *item,
 705		char *page)
 706{
 707	struct se_lun *lun = to_transport_stat(item);
 708	struct se_device *dev;
 709	struct se_portal_group *tpg = lun->lun_tpg;
 710	ssize_t ret = -ENODEV;
 711
 712	rcu_read_lock();
 713	dev = rcu_dereference(lun->lun_se_dev);
 714	if (dev) {
 715		/* scsiTransportType */
 716		ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
 717			       tpg->se_tpg_tfo->fabric_name);
 718	}
 719	rcu_read_unlock();
 720	return ret;
 721}
 722
 723static ssize_t target_stat_transport_indx_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		ret = snprintf(page, PAGE_SIZE, "%u\n",
 735			       tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 736	rcu_read_unlock();
 737	return ret;
 738}
 739
 740static ssize_t target_stat_transport_dev_name_show(struct config_item *item,
 741		char *page)
 742{
 743	struct se_lun *lun = to_transport_stat(item);
 744	struct se_device *dev;
 745	struct se_portal_group *tpg = lun->lun_tpg;
 746	struct t10_wwn *wwn;
 747	ssize_t ret = -ENODEV;
 748
 749	rcu_read_lock();
 750	dev = rcu_dereference(lun->lun_se_dev);
 751	if (dev) {
 752		wwn = &dev->t10_wwn;
 753		/* scsiTransportDevName */
 754		ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
 755				tpg->se_tpg_tfo->tpg_get_wwn(tpg),
 756				(strlen(wwn->unit_serial)) ? wwn->unit_serial :
 757				wwn->vendor);
 758	}
 759	rcu_read_unlock();
 760	return ret;
 761}
 762
 763static ssize_t target_stat_transport_proto_id_show(struct config_item *item,
 764		char *page)
 765{
 766	struct se_lun *lun = to_transport_stat(item);
 767	struct se_device *dev;
 768	struct se_portal_group *tpg = lun->lun_tpg;
 769	ssize_t ret = -ENODEV;
 770
 771	rcu_read_lock();
 772	dev = rcu_dereference(lun->lun_se_dev);
 773	if (dev)
 774		ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->proto_id);
 775	rcu_read_unlock();
 776	return ret;
 777}
 778
 779CONFIGFS_ATTR_RO(target_stat_transport_, inst);
 780CONFIGFS_ATTR_RO(target_stat_transport_, device);
 781CONFIGFS_ATTR_RO(target_stat_transport_, indx);
 782CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
 783CONFIGFS_ATTR_RO(target_stat_transport_, proto_id);
 784
 785static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
 786	&target_stat_transport_attr_inst,
 787	&target_stat_transport_attr_device,
 788	&target_stat_transport_attr_indx,
 789	&target_stat_transport_attr_dev_name,
 790	&target_stat_transport_attr_proto_id,
 791	NULL,
 792};
 793
 794static const struct config_item_type target_stat_scsi_transport_cit = {
 795	.ct_attrs		= target_stat_scsi_transport_attrs,
 796	.ct_owner		= THIS_MODULE,
 797};
 798
 799/*
 800 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
 801 * the target port statistics groups + configfs CITs located in target_core_stat.c
 802 */
 803void target_stat_setup_port_default_groups(struct se_lun *lun)
 804{
 805	config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
 806			"scsi_port", &target_stat_scsi_port_cit);
 807	configfs_add_default_group(&lun->port_stat_grps.scsi_port_group,
 808			&lun->port_stat_grps.stat_group);
 809
 810	config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
 811			"scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
 812	configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group,
 813			&lun->port_stat_grps.stat_group);
 814
 815	config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
 816			"scsi_transport", &target_stat_scsi_transport_cit);
 817	configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group,
 818			&lun->port_stat_grps.stat_group);
 819}
 820
 821/*
 822 * SCSI Authorized Initiator Table
 823 */
 824
 825static struct se_lun_acl *auth_to_lacl(struct config_item *item)
 826{
 827	struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
 828			struct se_ml_stat_grps, scsi_auth_intr_group);
 829	return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
 830}
 831
 832static ssize_t target_stat_auth_inst_show(struct config_item *item,
 833		char *page)
 834{
 835	struct se_lun_acl *lacl = auth_to_lacl(item);
 836	struct se_node_acl *nacl = lacl->se_lun_nacl;
 837	struct se_dev_entry *deve;
 838	struct se_portal_group *tpg;
 839	ssize_t ret;
 840
 841	rcu_read_lock();
 842	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 843	if (!deve) {
 844		rcu_read_unlock();
 845		return -ENODEV;
 846	}
 847	tpg = nacl->se_tpg;
 848	/* scsiInstIndex */
 849	ret = snprintf(page, PAGE_SIZE, "%u\n",
 850			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 851	rcu_read_unlock();
 852	return ret;
 853}
 854
 855static ssize_t target_stat_auth_dev_show(struct config_item *item,
 856		char *page)
 857{
 858	struct se_lun_acl *lacl = auth_to_lacl(item);
 859	struct se_node_acl *nacl = lacl->se_lun_nacl;
 860	struct se_dev_entry *deve;
 861	ssize_t ret;
 862
 863	rcu_read_lock();
 864	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 865	if (!deve) {
 866		rcu_read_unlock();
 867		return -ENODEV;
 868	}
 869
 870	/* scsiDeviceIndex */
 871	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->se_lun->lun_index);
 872	rcu_read_unlock();
 873	return ret;
 874}
 875
 876static ssize_t target_stat_auth_port_show(struct config_item *item,
 877		char *page)
 878{
 879	struct se_lun_acl *lacl = auth_to_lacl(item);
 880	struct se_node_acl *nacl = lacl->se_lun_nacl;
 881	struct se_dev_entry *deve;
 882	struct se_portal_group *tpg;
 883	ssize_t ret;
 884
 885	rcu_read_lock();
 886	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 887	if (!deve) {
 888		rcu_read_unlock();
 889		return -ENODEV;
 890	}
 891	tpg = nacl->se_tpg;
 892	/* scsiAuthIntrTgtPortIndex */
 893	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
 894	rcu_read_unlock();
 895	return ret;
 896}
 897
 898static ssize_t target_stat_auth_indx_show(struct config_item *item,
 899		char *page)
 900{
 901	struct se_lun_acl *lacl = auth_to_lacl(item);
 902	struct se_node_acl *nacl = lacl->se_lun_nacl;
 903	struct se_dev_entry *deve;
 904	ssize_t ret;
 905
 906	rcu_read_lock();
 907	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 908	if (!deve) {
 909		rcu_read_unlock();
 910		return -ENODEV;
 911	}
 912	/* scsiAuthIntrIndex */
 913	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
 914	rcu_read_unlock();
 915	return ret;
 916}
 917
 918static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
 919		char *page)
 920{
 921	struct se_lun_acl *lacl = auth_to_lacl(item);
 922	struct se_node_acl *nacl = lacl->se_lun_nacl;
 923	struct se_dev_entry *deve;
 924	ssize_t ret;
 925
 926	rcu_read_lock();
 927	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 928	if (!deve) {
 929		rcu_read_unlock();
 930		return -ENODEV;
 931	}
 932	/* scsiAuthIntrDevOrPort */
 933	ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
 934	rcu_read_unlock();
 935	return ret;
 936}
 937
 938static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
 939		char *page)
 940{
 941	struct se_lun_acl *lacl = auth_to_lacl(item);
 942	struct se_node_acl *nacl = lacl->se_lun_nacl;
 943	struct se_dev_entry *deve;
 944	ssize_t ret;
 945
 946	rcu_read_lock();
 947	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 948	if (!deve) {
 949		rcu_read_unlock();
 950		return -ENODEV;
 951	}
 952	/* scsiAuthIntrName */
 953	ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
 954	rcu_read_unlock();
 955	return ret;
 956}
 957
 958static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
 959		char *page)
 960{
 961	struct se_lun_acl *lacl = auth_to_lacl(item);
 962	struct se_node_acl *nacl = lacl->se_lun_nacl;
 963	struct se_dev_entry *deve;
 964	ssize_t ret;
 965
 966	rcu_read_lock();
 967	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 968	if (!deve) {
 969		rcu_read_unlock();
 970		return -ENODEV;
 971	}
 972	/* FIXME: scsiAuthIntrLunMapIndex */
 973	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 974	rcu_read_unlock();
 975	return ret;
 976}
 977
 978static ssize_t target_stat_auth_att_count_show(struct config_item *item,
 979		char *page)
 980{
 981	struct se_lun_acl *lacl = auth_to_lacl(item);
 982	struct se_node_acl *nacl = lacl->se_lun_nacl;
 983	struct se_dev_entry *deve;
 984	ssize_t ret;
 985
 986	rcu_read_lock();
 987	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 988	if (!deve) {
 989		rcu_read_unlock();
 990		return -ENODEV;
 991	}
 992	/* scsiAuthIntrAttachedTimes */
 993	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
 994	rcu_read_unlock();
 995	return ret;
 996}
 997
 998#define auth_show_per_cpu_stat(prefix, field, shift)			\
 999per_cpu_stat_snprintf(se_dev_entry_io_stats, prefix, field, shift);	\
1000static ssize_t								\
1001target_stat_##prefix##_show(struct config_item *item, char *page)	\
1002{									\
1003	struct se_lun_acl *lacl = auth_to_lacl(item);			\
1004	struct se_node_acl *nacl = lacl->se_lun_nacl;			\
1005	struct se_dev_entry *deve;					\
1006	int ret;							\
1007									\
1008	rcu_read_lock();						\
1009	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);		\
1010	if (!deve) {							\
1011		rcu_read_unlock();					\
1012		return -ENODEV;						\
1013	}								\
1014									\
1015	ret = per_cpu_stat_##prefix##_snprintf(deve->stats, page);	\
1016	rcu_read_unlock();						\
1017	return ret;							\
1018}
1019
1020/* scsiAuthIntrOutCommands */
1021auth_show_per_cpu_stat(auth_num_cmds, total_cmds, 0);
1022/* scsiAuthIntrReadMegaBytes */
1023auth_show_per_cpu_stat(auth_read_mbytes, read_bytes, 20);
1024/* scsiAuthIntrWrittenMegaBytes */
1025auth_show_per_cpu_stat(auth_write_mbytes, write_bytes, 20);
1026
1027static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1028		char *page)
1029{
1030	struct se_lun_acl *lacl = auth_to_lacl(item);
1031	struct se_node_acl *nacl = lacl->se_lun_nacl;
1032	struct se_dev_entry *deve;
1033	ssize_t ret;
1034
1035	rcu_read_lock();
1036	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1037	if (!deve) {
1038		rcu_read_unlock();
1039		return -ENODEV;
1040	}
1041	/* FIXME: scsiAuthIntrHSOutCommands */
1042	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1043	rcu_read_unlock();
1044	return ret;
1045}
1046
1047static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1048		char *page)
1049{
1050	struct se_lun_acl *lacl = auth_to_lacl(item);
1051	struct se_node_acl *nacl = lacl->se_lun_nacl;
1052	struct se_dev_entry *deve;
1053	ssize_t ret;
1054
1055	rcu_read_lock();
1056	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1057	if (!deve) {
1058		rcu_read_unlock();
1059		return -ENODEV;
1060	}
1061	/* scsiAuthIntrLastCreation */
1062	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1063				INITIAL_JIFFIES) * 100 / HZ));
1064	rcu_read_unlock();
1065	return ret;
1066}
1067
1068static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1069		char *page)
1070{
1071	struct se_lun_acl *lacl = auth_to_lacl(item);
1072	struct se_node_acl *nacl = lacl->se_lun_nacl;
1073	struct se_dev_entry *deve;
1074	ssize_t ret;
1075
1076	rcu_read_lock();
1077	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1078	if (!deve) {
1079		rcu_read_unlock();
1080		return -ENODEV;
1081	}
1082	/* FIXME: scsiAuthIntrRowStatus */
1083	ret = snprintf(page, PAGE_SIZE, "Ready\n");
1084	rcu_read_unlock();
1085	return ret;
1086}
1087
1088CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1089CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1090CONFIGFS_ATTR_RO(target_stat_auth_, port);
1091CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1092CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1093CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1094CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1095CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1096CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1097CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1098CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1099CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1100CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1101CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1102
1103static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1104	&target_stat_auth_attr_inst,
1105	&target_stat_auth_attr_dev,
1106	&target_stat_auth_attr_port,
1107	&target_stat_auth_attr_indx,
1108	&target_stat_auth_attr_dev_or_port,
1109	&target_stat_auth_attr_intr_name,
1110	&target_stat_auth_attr_map_indx,
1111	&target_stat_auth_attr_att_count,
1112	&target_stat_auth_attr_num_cmds,
1113	&target_stat_auth_attr_read_mbytes,
1114	&target_stat_auth_attr_write_mbytes,
1115	&target_stat_auth_attr_hs_num_cmds,
1116	&target_stat_auth_attr_creation_time,
1117	&target_stat_auth_attr_row_status,
1118	NULL,
1119};
1120
1121static const struct config_item_type target_stat_scsi_auth_intr_cit = {
1122	.ct_attrs		= target_stat_scsi_auth_intr_attrs,
1123	.ct_owner		= THIS_MODULE,
1124};
1125
1126/*
1127 * SCSI Attached Initiator Port Table
1128 */
1129
1130static struct se_lun_acl *iport_to_lacl(struct config_item *item)
1131{
1132	struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1133			struct se_ml_stat_grps, scsi_att_intr_port_group);
1134	return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1135}
1136
1137static ssize_t target_stat_iport_inst_show(struct config_item *item,
1138		char *page)
1139{
1140	struct se_lun_acl *lacl = iport_to_lacl(item);
1141	struct se_node_acl *nacl = lacl->se_lun_nacl;
1142	struct se_dev_entry *deve;
1143	struct se_portal_group *tpg;
1144	ssize_t ret;
1145
1146	rcu_read_lock();
1147	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1148	if (!deve) {
1149		rcu_read_unlock();
1150		return -ENODEV;
1151	}
1152	tpg = nacl->se_tpg;
1153	/* scsiInstIndex */
1154	ret = snprintf(page, PAGE_SIZE, "%u\n",
1155			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1156	rcu_read_unlock();
1157	return ret;
1158}
1159
1160static ssize_t target_stat_iport_dev_show(struct config_item *item,
1161		char *page)
1162{
1163	struct se_lun_acl *lacl = iport_to_lacl(item);
1164	struct se_node_acl *nacl = lacl->se_lun_nacl;
1165	struct se_dev_entry *deve;
1166	ssize_t ret;
1167
1168	rcu_read_lock();
1169	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1170	if (!deve) {
1171		rcu_read_unlock();
1172		return -ENODEV;
1173	}
1174
1175	/* scsiDeviceIndex */
1176	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->se_lun->lun_index);
1177	rcu_read_unlock();
1178	return ret;
1179}
1180
1181static ssize_t target_stat_iport_port_show(struct config_item *item,
1182		char *page)
1183{
1184	struct se_lun_acl *lacl = iport_to_lacl(item);
1185	struct se_node_acl *nacl = lacl->se_lun_nacl;
1186	struct se_dev_entry *deve;
1187	struct se_portal_group *tpg;
1188	ssize_t ret;
1189
1190	rcu_read_lock();
1191	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1192	if (!deve) {
1193		rcu_read_unlock();
1194		return -ENODEV;
1195	}
1196	tpg = nacl->se_tpg;
1197	/* scsiPortIndex */
1198	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1199	rcu_read_unlock();
1200	return ret;
1201}
1202
1203static ssize_t target_stat_iport_indx_show(struct config_item *item,
1204		char *page)
1205{
1206	struct se_lun_acl *lacl = iport_to_lacl(item);
1207	struct se_node_acl *nacl = lacl->se_lun_nacl;
1208	struct se_session *se_sess;
1209	struct se_portal_group *tpg;
1210	ssize_t ret;
1211
1212	spin_lock_irq(&nacl->nacl_sess_lock);
1213	se_sess = nacl->nacl_sess;
1214	if (!se_sess) {
1215		spin_unlock_irq(&nacl->nacl_sess_lock);
1216		return -ENODEV;
1217	}
1218
1219	tpg = nacl->se_tpg;
1220	/* scsiAttIntrPortIndex */
1221	ret = snprintf(page, PAGE_SIZE, "%u\n",
1222			tpg->se_tpg_tfo->sess_get_index(se_sess));
1223	spin_unlock_irq(&nacl->nacl_sess_lock);
1224	return ret;
1225}
1226
1227static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item,
1228		char *page)
1229{
1230	struct se_lun_acl *lacl = iport_to_lacl(item);
1231	struct se_node_acl *nacl = lacl->se_lun_nacl;
1232	struct se_dev_entry *deve;
1233	ssize_t ret;
1234
1235	rcu_read_lock();
1236	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1237	if (!deve) {
1238		rcu_read_unlock();
1239		return -ENODEV;
1240	}
1241	/* scsiAttIntrPortAuthIntrIdx */
1242	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1243	rcu_read_unlock();
1244	return ret;
1245}
1246
1247static ssize_t target_stat_iport_port_ident_show(struct config_item *item,
1248		char *page)
1249{
1250	struct se_lun_acl *lacl = iport_to_lacl(item);
1251	struct se_node_acl *nacl = lacl->se_lun_nacl;
1252	struct se_session *se_sess;
1253	struct se_portal_group *tpg;
1254	ssize_t ret;
1255	unsigned char buf[64];
1256
1257	spin_lock_irq(&nacl->nacl_sess_lock);
1258	se_sess = nacl->nacl_sess;
1259	if (!se_sess) {
1260		spin_unlock_irq(&nacl->nacl_sess_lock);
1261		return -ENODEV;
1262	}
1263
1264	tpg = nacl->se_tpg;
1265	/* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1266	memset(buf, 0, 64);
1267	if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1268		tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1269
1270	ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1271	spin_unlock_irq(&nacl->nacl_sess_lock);
1272	return ret;
1273}
1274
1275CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1276CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1277CONFIGFS_ATTR_RO(target_stat_iport_, port);
1278CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1279CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1280CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
1281
1282static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1283	&target_stat_iport_attr_inst,
1284	&target_stat_iport_attr_dev,
1285	&target_stat_iport_attr_port,
1286	&target_stat_iport_attr_indx,
1287	&target_stat_iport_attr_port_auth_indx,
1288	&target_stat_iport_attr_port_ident,
1289	NULL,
1290};
1291
1292static const struct config_item_type target_stat_scsi_att_intr_port_cit = {
1293	.ct_attrs		= target_stat_scsi_ath_intr_port_attrs,
1294	.ct_owner		= THIS_MODULE,
1295};
1296
1297/*
1298 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1299 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1300 */
1301void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1302{
1303	config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1304			"scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1305	configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group,
1306			&lacl->ml_stat_grps.stat_group);
1307
1308	config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1309			"scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1310	configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1311			&lacl->ml_stat_grps.stat_group);
1312}