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
  57static 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
  64static 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
  71static 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
  76static ssize_t target_stat_role_show(struct config_item *item, char *page)
  77{
  78	return snprintf(page, PAGE_SIZE, "Target\n");
  79}
  80
  81static 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
  86CONFIGFS_ATTR_RO(target_stat_, inst);
  87CONFIGFS_ATTR_RO(target_stat_, indx);
  88CONFIGFS_ATTR_RO(target_stat_, role);
  89CONFIGFS_ATTR_RO(target_stat_, ports);
  90
  91static 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
  99static 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 */
 107static 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
 114static 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
 121static 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
 126static 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
 132static 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
 141static 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
 154static 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
 161CONFIGFS_ATTR_RO(target_stat_tgt_, inst);
 162CONFIGFS_ATTR_RO(target_stat_tgt_, indx);
 163CONFIGFS_ATTR_RO(target_stat_tgt_, num_lus);
 164CONFIGFS_ATTR_RO(target_stat_tgt_, status);
 165CONFIGFS_ATTR_RO(target_stat_tgt_, non_access_lus);
 166CONFIGFS_ATTR_RO(target_stat_tgt_, resets);
 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	NULL,
 176};
 177
 178static 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
 187static 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
 194static 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
 201static 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
 207static 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
 212static 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
 218static 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
 228static 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
 242static 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
 256static 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
 270static 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
 279static 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
 288static 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
 295static 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
 305static 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
 315static 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
 325static 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
 334static 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
 341static 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
 348static 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
 358CONFIGFS_ATTR_RO(target_stat_lu_, inst);
 359CONFIGFS_ATTR_RO(target_stat_lu_, dev);
 360CONFIGFS_ATTR_RO(target_stat_lu_, indx);
 361CONFIGFS_ATTR_RO(target_stat_lu_, lun);
 362CONFIGFS_ATTR_RO(target_stat_lu_, lu_name);
 363CONFIGFS_ATTR_RO(target_stat_lu_, vend);
 364CONFIGFS_ATTR_RO(target_stat_lu_, prod);
 365CONFIGFS_ATTR_RO(target_stat_lu_, rev);
 366CONFIGFS_ATTR_RO(target_stat_lu_, dev_type);
 367CONFIGFS_ATTR_RO(target_stat_lu_, status);
 368CONFIGFS_ATTR_RO(target_stat_lu_, state_bit);
 369CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds);
 370CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes);
 371CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes);
 372CONFIGFS_ATTR_RO(target_stat_lu_, resets);
 373CONFIGFS_ATTR_RO(target_stat_lu_, full_stat);
 374CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds);
 375CONFIGFS_ATTR_RO(target_stat_lu_, creation_time);
 376
 377static 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
 399static 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 */
 408void target_stat_setup_dev_default_groups(struct se_device *dev)
 409{
 410	config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
 411			"scsi_dev", &target_stat_scsi_dev_cit);
 412	configfs_add_default_group(&dev->dev_stat_grps.scsi_dev_group,
 413			&dev->dev_stat_grps.stat_group);
 414
 415	config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
 416			"scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 417	configfs_add_default_group(&dev->dev_stat_grps.scsi_tgt_dev_group,
 418			&dev->dev_stat_grps.stat_group);
 419
 420	config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
 421			"scsi_lu", &target_stat_scsi_lu_cit);
 422	configfs_add_default_group(&dev->dev_stat_grps.scsi_lu_group,
 423			&dev->dev_stat_grps.stat_group);
 424}
 425
 426/*
 427 * SCSI Port Table
 428 */
 429
 430static struct se_lun *to_stat_port(struct config_item *item)
 431{
 432	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 433			struct se_port_stat_grps, scsi_port_group);
 434	return container_of(pgrps, struct se_lun, port_stat_grps);
 435}
 436
 437static ssize_t target_stat_port_inst_show(struct config_item *item, char *page)
 438{
 439	struct se_lun *lun = to_stat_port(item);
 440	struct se_device *dev;
 441	ssize_t ret = -ENODEV;
 442
 443	rcu_read_lock();
 444	dev = rcu_dereference(lun->lun_se_dev);
 445	if (dev)
 446		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 447	rcu_read_unlock();
 448	return ret;
 449}
 450
 451static ssize_t target_stat_port_dev_show(struct config_item *item, char *page)
 452{
 453	struct se_lun *lun = to_stat_port(item);
 454	struct se_device *dev;
 455	ssize_t ret = -ENODEV;
 456
 457	rcu_read_lock();
 458	dev = rcu_dereference(lun->lun_se_dev);
 459	if (dev)
 460		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 461	rcu_read_unlock();
 462	return ret;
 463}
 464
 465static ssize_t target_stat_port_indx_show(struct config_item *item, char *page)
 466{
 467	struct se_lun *lun = to_stat_port(item);
 468	struct se_device *dev;
 469	ssize_t ret = -ENODEV;
 470
 471	rcu_read_lock();
 472	dev = rcu_dereference(lun->lun_se_dev);
 473	if (dev)
 474		ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
 475	rcu_read_unlock();
 476	return ret;
 477}
 478
 479static ssize_t target_stat_port_role_show(struct config_item *item, char *page)
 480{
 481	struct se_lun *lun = to_stat_port(item);
 482	struct se_device *dev;
 483	ssize_t ret = -ENODEV;
 484
 485	rcu_read_lock();
 486	dev = rcu_dereference(lun->lun_se_dev);
 487	if (dev)
 488		ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 489	rcu_read_unlock();
 490	return ret;
 491}
 492
 493static ssize_t target_stat_port_busy_count_show(struct config_item *item,
 494		char *page)
 495{
 496	struct se_lun *lun = to_stat_port(item);
 497	struct se_device *dev;
 498	ssize_t ret = -ENODEV;
 499
 500	rcu_read_lock();
 501	dev = rcu_dereference(lun->lun_se_dev);
 502	if (dev) {
 503		/* FIXME: scsiPortBusyStatuses  */
 504		ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 505	}
 506	rcu_read_unlock();
 507	return ret;
 508}
 509
 510CONFIGFS_ATTR_RO(target_stat_port_, inst);
 511CONFIGFS_ATTR_RO(target_stat_port_, dev);
 512CONFIGFS_ATTR_RO(target_stat_port_, indx);
 513CONFIGFS_ATTR_RO(target_stat_port_, role);
 514CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
 515
 516static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 517	&target_stat_port_attr_inst,
 518	&target_stat_port_attr_dev,
 519	&target_stat_port_attr_indx,
 520	&target_stat_port_attr_role,
 521	&target_stat_port_attr_busy_count,
 522	NULL,
 523};
 524
 525static struct config_item_type target_stat_scsi_port_cit = {
 526	.ct_attrs		= target_stat_scsi_port_attrs,
 527	.ct_owner		= THIS_MODULE,
 528};
 529
 530/*
 531 * SCSI Target Port Table
 532 */
 533static struct se_lun *to_stat_tgt_port(struct config_item *item)
 534{
 535	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 536			struct se_port_stat_grps, scsi_tgt_port_group);
 537	return container_of(pgrps, struct se_lun, port_stat_grps);
 538}
 539
 540static ssize_t target_stat_tgt_port_inst_show(struct config_item *item,
 541		char *page)
 542{
 543	struct se_lun *lun = to_stat_tgt_port(item);
 544	struct se_device *dev;
 545	ssize_t ret = -ENODEV;
 546
 547	rcu_read_lock();
 548	dev = rcu_dereference(lun->lun_se_dev);
 549	if (dev)
 550		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 551	rcu_read_unlock();
 552	return ret;
 553}
 554
 555static ssize_t target_stat_tgt_port_dev_show(struct config_item *item,
 556		char *page)
 557{
 558	struct se_lun *lun = to_stat_tgt_port(item);
 559	struct se_device *dev;
 560	ssize_t ret = -ENODEV;
 561
 562	rcu_read_lock();
 563	dev = rcu_dereference(lun->lun_se_dev);
 564	if (dev)
 565		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 566	rcu_read_unlock();
 567	return ret;
 568}
 569
 570static ssize_t target_stat_tgt_port_indx_show(struct config_item *item,
 571		char *page)
 572{
 573	struct se_lun *lun = to_stat_tgt_port(item);
 574	struct se_device *dev;
 575	ssize_t ret = -ENODEV;
 576
 577	rcu_read_lock();
 578	dev = rcu_dereference(lun->lun_se_dev);
 579	if (dev)
 580		ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
 581	rcu_read_unlock();
 582	return ret;
 583}
 584
 585static ssize_t target_stat_tgt_port_name_show(struct config_item *item,
 586		char *page)
 587{
 588	struct se_lun *lun = to_stat_tgt_port(item);
 589	struct se_portal_group *tpg = lun->lun_tpg;
 590	struct se_device *dev;
 591	ssize_t ret = -ENODEV;
 592
 593	rcu_read_lock();
 594	dev = rcu_dereference(lun->lun_se_dev);
 595	if (dev)
 596		ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 597			tpg->se_tpg_tfo->get_fabric_name(),
 598			lun->lun_rtpi);
 599	rcu_read_unlock();
 600	return ret;
 601}
 602
 603static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item,
 604		char *page)
 605{
 606	struct se_lun *lun = to_stat_tgt_port(item);
 607	struct se_portal_group *tpg = lun->lun_tpg;
 608	struct se_device *dev;
 609	ssize_t ret = -ENODEV;
 610
 611	rcu_read_lock();
 612	dev = rcu_dereference(lun->lun_se_dev);
 613	if (dev)
 614		ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 615			tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 616			tpg->se_tpg_tfo->tpg_get_tag(tpg));
 617	rcu_read_unlock();
 618	return ret;
 619}
 620
 621static ssize_t target_stat_tgt_port_in_cmds_show(struct config_item *item,
 622		char *page)
 623{
 624	struct se_lun *lun = to_stat_tgt_port(item);
 625	struct se_device *dev;
 626	ssize_t ret = -ENODEV;
 627
 628	rcu_read_lock();
 629	dev = rcu_dereference(lun->lun_se_dev);
 630	if (dev)
 631		ret = snprintf(page, PAGE_SIZE, "%lu\n",
 632			       atomic_long_read(&lun->lun_stats.cmd_pdus));
 633	rcu_read_unlock();
 634	return ret;
 635}
 636
 637static ssize_t target_stat_tgt_port_write_mbytes_show(struct config_item *item,
 638		char *page)
 639{
 640	struct se_lun *lun = to_stat_tgt_port(item);
 641	struct se_device *dev;
 642	ssize_t ret = -ENODEV;
 643
 644	rcu_read_lock();
 645	dev = rcu_dereference(lun->lun_se_dev);
 646	if (dev)
 647		ret = snprintf(page, PAGE_SIZE, "%u\n",
 648			(u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
 649	rcu_read_unlock();
 650	return ret;
 651}
 652
 653static ssize_t target_stat_tgt_port_read_mbytes_show(struct config_item *item,
 654		char *page)
 655{
 656	struct se_lun *lun = to_stat_tgt_port(item);
 657	struct se_device *dev;
 658	ssize_t ret = -ENODEV;
 659
 660	rcu_read_lock();
 661	dev = rcu_dereference(lun->lun_se_dev);
 662	if (dev)
 663		ret = snprintf(page, PAGE_SIZE, "%u\n",
 664				(u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
 665	rcu_read_unlock();
 666	return ret;
 667}
 668
 669static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item,
 670		char *page)
 671{
 672	struct se_lun *lun = to_stat_tgt_port(item);
 673	struct se_device *dev;
 674	ssize_t ret = -ENODEV;
 675
 676	rcu_read_lock();
 677	dev = rcu_dereference(lun->lun_se_dev);
 678	if (dev) {
 679		/* FIXME: scsiTgtPortHsInCommands */
 680		ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 681	}
 682	rcu_read_unlock();
 683	return ret;
 684}
 685
 686CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
 687CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
 688CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
 689CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
 690CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
 691CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
 692CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
 693CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
 694CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
 695
 696static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
 697	&target_stat_tgt_port_attr_inst,
 698	&target_stat_tgt_port_attr_dev,
 699	&target_stat_tgt_port_attr_indx,
 700	&target_stat_tgt_port_attr_name,
 701	&target_stat_tgt_port_attr_port_index,
 702	&target_stat_tgt_port_attr_in_cmds,
 703	&target_stat_tgt_port_attr_write_mbytes,
 704	&target_stat_tgt_port_attr_read_mbytes,
 705	&target_stat_tgt_port_attr_hs_in_cmds,
 706	NULL,
 707};
 708
 709static struct config_item_type target_stat_scsi_tgt_port_cit = {
 710	.ct_attrs		= target_stat_scsi_tgt_port_attrs,
 711	.ct_owner		= THIS_MODULE,
 712};
 713
 714/*
 715 * SCSI Transport Table
 716 */
 717static struct se_lun *to_transport_stat(struct config_item *item)
 718{
 719	struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
 720			struct se_port_stat_grps, scsi_transport_group);
 721	return container_of(pgrps, struct se_lun, port_stat_grps);
 722}
 723
 724static ssize_t target_stat_transport_inst_show(struct config_item *item,
 725		char *page)
 726{
 727	struct se_lun *lun = to_transport_stat(item);
 728	struct se_device *dev;
 729	ssize_t ret = -ENODEV;
 730
 731	rcu_read_lock();
 732	dev = rcu_dereference(lun->lun_se_dev);
 733	if (dev)
 734		ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
 735	rcu_read_unlock();
 736	return ret;
 737}
 738
 739static ssize_t target_stat_transport_device_show(struct config_item *item,
 740		char *page)
 741{
 742	struct se_lun *lun = to_transport_stat(item);
 743	struct se_device *dev;
 744	struct se_portal_group *tpg = lun->lun_tpg;
 745	ssize_t ret = -ENODEV;
 746
 747	rcu_read_lock();
 748	dev = rcu_dereference(lun->lun_se_dev);
 749	if (dev) {
 750		/* scsiTransportType */
 751		ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
 752			       tpg->se_tpg_tfo->get_fabric_name());
 753	}
 754	rcu_read_unlock();
 755	return ret;
 756}
 757
 758static ssize_t target_stat_transport_indx_show(struct config_item *item,
 759		char *page)
 760{
 761	struct se_lun *lun = to_transport_stat(item);
 762	struct se_device *dev;
 763	struct se_portal_group *tpg = lun->lun_tpg;
 764	ssize_t ret = -ENODEV;
 765
 766	rcu_read_lock();
 767	dev = rcu_dereference(lun->lun_se_dev);
 768	if (dev)
 769		ret = snprintf(page, PAGE_SIZE, "%u\n",
 770			       tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 771	rcu_read_unlock();
 772	return ret;
 773}
 774
 775static ssize_t target_stat_transport_dev_name_show(struct config_item *item,
 776		char *page)
 777{
 778	struct se_lun *lun = to_transport_stat(item);
 779	struct se_device *dev;
 780	struct se_portal_group *tpg = lun->lun_tpg;
 781	struct t10_wwn *wwn;
 782	ssize_t ret = -ENODEV;
 783
 784	rcu_read_lock();
 785	dev = rcu_dereference(lun->lun_se_dev);
 786	if (dev) {
 787		wwn = &dev->t10_wwn;
 788		/* scsiTransportDevName */
 789		ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
 790				tpg->se_tpg_tfo->tpg_get_wwn(tpg),
 791				(strlen(wwn->unit_serial)) ? wwn->unit_serial :
 792				wwn->vendor);
 793	}
 794	rcu_read_unlock();
 795	return ret;
 796}
 797
 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);
 802
 803static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
 804	&target_stat_transport_attr_inst,
 805	&target_stat_transport_attr_device,
 806	&target_stat_transport_attr_indx,
 807	&target_stat_transport_attr_dev_name,
 808	NULL,
 809};
 810
 811static struct config_item_type target_stat_scsi_transport_cit = {
 812	.ct_attrs		= target_stat_scsi_transport_attrs,
 813	.ct_owner		= THIS_MODULE,
 814};
 815
 816/*
 817 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
 818 * the target port statistics groups + configfs CITs located in target_core_stat.c
 819 */
 820void target_stat_setup_port_default_groups(struct se_lun *lun)
 821{
 822	config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
 823			"scsi_port", &target_stat_scsi_port_cit);
 824	configfs_add_default_group(&lun->port_stat_grps.scsi_port_group,
 825			&lun->port_stat_grps.stat_group);
 826
 827	config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
 828			"scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
 829	configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group,
 830			&lun->port_stat_grps.stat_group);
 831
 832	config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
 833			"scsi_transport", &target_stat_scsi_transport_cit);
 834	configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group,
 835			&lun->port_stat_grps.stat_group);
 836}
 837
 838/*
 839 * SCSI Authorized Initiator Table
 840 */
 841
 842static struct se_lun_acl *auth_to_lacl(struct config_item *item)
 843{
 844	struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
 845			struct se_ml_stat_grps, scsi_auth_intr_group);
 846	return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
 847}
 848
 849static ssize_t target_stat_auth_inst_show(struct config_item *item,
 850		char *page)
 851{
 852	struct se_lun_acl *lacl = auth_to_lacl(item);
 853	struct se_node_acl *nacl = lacl->se_lun_nacl;
 854	struct se_dev_entry *deve;
 855	struct se_portal_group *tpg;
 856	ssize_t ret;
 857
 858	rcu_read_lock();
 859	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 860	if (!deve) {
 861		rcu_read_unlock();
 862		return -ENODEV;
 863	}
 864	tpg = nacl->se_tpg;
 865	/* scsiInstIndex */
 866	ret = snprintf(page, PAGE_SIZE, "%u\n",
 867			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 868	rcu_read_unlock();
 869	return ret;
 870}
 871
 872static ssize_t target_stat_auth_dev_show(struct config_item *item,
 873		char *page)
 874{
 875	struct se_lun_acl *lacl = auth_to_lacl(item);
 876	struct se_node_acl *nacl = lacl->se_lun_nacl;
 877	struct se_dev_entry *deve;
 878	struct se_lun *lun;
 879	ssize_t ret;
 880
 881	rcu_read_lock();
 882	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 883	if (!deve) {
 884		rcu_read_unlock();
 885		return -ENODEV;
 886	}
 887	lun = rcu_dereference(deve->se_lun);
 888	/* scsiDeviceIndex */
 889	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
 890	rcu_read_unlock();
 891	return ret;
 892}
 893
 894static ssize_t target_stat_auth_port_show(struct config_item *item,
 895		char *page)
 896{
 897	struct se_lun_acl *lacl = auth_to_lacl(item);
 898	struct se_node_acl *nacl = lacl->se_lun_nacl;
 899	struct se_dev_entry *deve;
 900	struct se_portal_group *tpg;
 901	ssize_t ret;
 902
 903	rcu_read_lock();
 904	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 905	if (!deve) {
 906		rcu_read_unlock();
 907		return -ENODEV;
 908	}
 909	tpg = nacl->se_tpg;
 910	/* scsiAuthIntrTgtPortIndex */
 911	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
 912	rcu_read_unlock();
 913	return ret;
 914}
 915
 916static ssize_t target_stat_auth_indx_show(struct config_item *item,
 917		char *page)
 918{
 919	struct se_lun_acl *lacl = auth_to_lacl(item);
 920	struct se_node_acl *nacl = lacl->se_lun_nacl;
 921	struct se_dev_entry *deve;
 922	ssize_t ret;
 923
 924	rcu_read_lock();
 925	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 926	if (!deve) {
 927		rcu_read_unlock();
 928		return -ENODEV;
 929	}
 930	/* scsiAuthIntrIndex */
 931	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
 932	rcu_read_unlock();
 933	return ret;
 934}
 935
 936static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
 937		char *page)
 938{
 939	struct se_lun_acl *lacl = auth_to_lacl(item);
 940	struct se_node_acl *nacl = lacl->se_lun_nacl;
 941	struct se_dev_entry *deve;
 942	ssize_t ret;
 943
 944	rcu_read_lock();
 945	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 946	if (!deve) {
 947		rcu_read_unlock();
 948		return -ENODEV;
 949	}
 950	/* scsiAuthIntrDevOrPort */
 951	ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
 952	rcu_read_unlock();
 953	return ret;
 954}
 955
 956static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
 957		char *page)
 958{
 959	struct se_lun_acl *lacl = auth_to_lacl(item);
 960	struct se_node_acl *nacl = lacl->se_lun_nacl;
 961	struct se_dev_entry *deve;
 962	ssize_t ret;
 963
 964	rcu_read_lock();
 965	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 966	if (!deve) {
 967		rcu_read_unlock();
 968		return -ENODEV;
 969	}
 970	/* scsiAuthIntrName */
 971	ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
 972	rcu_read_unlock();
 973	return ret;
 974}
 975
 976static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
 977		char *page)
 978{
 979	struct se_lun_acl *lacl = auth_to_lacl(item);
 980	struct se_node_acl *nacl = lacl->se_lun_nacl;
 981	struct se_dev_entry *deve;
 982	ssize_t ret;
 983
 984	rcu_read_lock();
 985	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
 986	if (!deve) {
 987		rcu_read_unlock();
 988		return -ENODEV;
 989	}
 990	/* FIXME: scsiAuthIntrLunMapIndex */
 991	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 992	rcu_read_unlock();
 993	return ret;
 994}
 995
 996static ssize_t target_stat_auth_att_count_show(struct config_item *item,
 997		char *page)
 998{
 999	struct se_lun_acl *lacl = auth_to_lacl(item);
1000	struct se_node_acl *nacl = lacl->se_lun_nacl;
1001	struct se_dev_entry *deve;
1002	ssize_t ret;
1003
1004	rcu_read_lock();
1005	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1006	if (!deve) {
1007		rcu_read_unlock();
1008		return -ENODEV;
1009	}
1010	/* scsiAuthIntrAttachedTimes */
1011	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1012	rcu_read_unlock();
1013	return ret;
1014}
1015
1016static ssize_t target_stat_auth_num_cmds_show(struct config_item *item,
1017		char *page)
1018{
1019	struct se_lun_acl *lacl = auth_to_lacl(item);
1020	struct se_node_acl *nacl = lacl->se_lun_nacl;
1021	struct se_dev_entry *deve;
1022	ssize_t ret;
1023
1024	rcu_read_lock();
1025	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1026	if (!deve) {
1027		rcu_read_unlock();
1028		return -ENODEV;
1029	}
1030	/* scsiAuthIntrOutCommands */
1031	ret = snprintf(page, PAGE_SIZE, "%lu\n",
1032		       atomic_long_read(&deve->total_cmds));
1033	rcu_read_unlock();
1034	return ret;
1035}
1036
1037static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item,
1038		char *page)
1039{
1040	struct se_lun_acl *lacl = auth_to_lacl(item);
1041	struct se_node_acl *nacl = lacl->se_lun_nacl;
1042	struct se_dev_entry *deve;
1043	ssize_t ret;
1044
1045	rcu_read_lock();
1046	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1047	if (!deve) {
1048		rcu_read_unlock();
1049		return -ENODEV;
1050	}
1051	/* scsiAuthIntrReadMegaBytes */
1052	ret = snprintf(page, PAGE_SIZE, "%u\n",
1053		      (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1054	rcu_read_unlock();
1055	return ret;
1056}
1057
1058static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item,
1059		char *page)
1060{
1061	struct se_lun_acl *lacl = auth_to_lacl(item);
1062	struct se_node_acl *nacl = lacl->se_lun_nacl;
1063	struct se_dev_entry *deve;
1064	ssize_t ret;
1065
1066	rcu_read_lock();
1067	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1068	if (!deve) {
1069		rcu_read_unlock();
1070		return -ENODEV;
1071	}
1072	/* scsiAuthIntrWrittenMegaBytes */
1073	ret = snprintf(page, PAGE_SIZE, "%u\n",
1074		      (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1075	rcu_read_unlock();
1076	return ret;
1077}
1078
1079static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1080		char *page)
1081{
1082	struct se_lun_acl *lacl = auth_to_lacl(item);
1083	struct se_node_acl *nacl = lacl->se_lun_nacl;
1084	struct se_dev_entry *deve;
1085	ssize_t ret;
1086
1087	rcu_read_lock();
1088	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1089	if (!deve) {
1090		rcu_read_unlock();
1091		return -ENODEV;
1092	}
1093	/* FIXME: scsiAuthIntrHSOutCommands */
1094	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1095	rcu_read_unlock();
1096	return ret;
1097}
1098
1099static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1100		char *page)
1101{
1102	struct se_lun_acl *lacl = auth_to_lacl(item);
1103	struct se_node_acl *nacl = lacl->se_lun_nacl;
1104	struct se_dev_entry *deve;
1105	ssize_t ret;
1106
1107	rcu_read_lock();
1108	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1109	if (!deve) {
1110		rcu_read_unlock();
1111		return -ENODEV;
1112	}
1113	/* scsiAuthIntrLastCreation */
1114	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1115				INITIAL_JIFFIES) * 100 / HZ));
1116	rcu_read_unlock();
1117	return ret;
1118}
1119
1120static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1121		char *page)
1122{
1123	struct se_lun_acl *lacl = auth_to_lacl(item);
1124	struct se_node_acl *nacl = lacl->se_lun_nacl;
1125	struct se_dev_entry *deve;
1126	ssize_t ret;
1127
1128	rcu_read_lock();
1129	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1130	if (!deve) {
1131		rcu_read_unlock();
1132		return -ENODEV;
1133	}
1134	/* FIXME: scsiAuthIntrRowStatus */
1135	ret = snprintf(page, PAGE_SIZE, "Ready\n");
1136	rcu_read_unlock();
1137	return ret;
1138}
1139
1140CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1141CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1142CONFIGFS_ATTR_RO(target_stat_auth_, port);
1143CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1144CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1145CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1146CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1147CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1148CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1149CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1150CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1151CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1152CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1153CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1154
1155static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1156	&target_stat_auth_attr_inst,
1157	&target_stat_auth_attr_dev,
1158	&target_stat_auth_attr_port,
1159	&target_stat_auth_attr_indx,
1160	&target_stat_auth_attr_dev_or_port,
1161	&target_stat_auth_attr_intr_name,
1162	&target_stat_auth_attr_map_indx,
1163	&target_stat_auth_attr_att_count,
1164	&target_stat_auth_attr_num_cmds,
1165	&target_stat_auth_attr_read_mbytes,
1166	&target_stat_auth_attr_write_mbytes,
1167	&target_stat_auth_attr_hs_num_cmds,
1168	&target_stat_auth_attr_creation_time,
1169	&target_stat_auth_attr_row_status,
1170	NULL,
1171};
1172
1173static struct config_item_type target_stat_scsi_auth_intr_cit = {
1174	.ct_attrs		= target_stat_scsi_auth_intr_attrs,
1175	.ct_owner		= THIS_MODULE,
1176};
1177
1178/*
1179 * SCSI Attached Initiator Port Table
1180 */
1181
1182static struct se_lun_acl *iport_to_lacl(struct config_item *item)
1183{
1184	struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1185			struct se_ml_stat_grps, scsi_att_intr_port_group);
1186	return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1187}
1188
1189static ssize_t target_stat_iport_inst_show(struct config_item *item,
1190		char *page)
1191{
1192	struct se_lun_acl *lacl = iport_to_lacl(item);
1193	struct se_node_acl *nacl = lacl->se_lun_nacl;
1194	struct se_dev_entry *deve;
1195	struct se_portal_group *tpg;
1196	ssize_t ret;
1197
1198	rcu_read_lock();
1199	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1200	if (!deve) {
1201		rcu_read_unlock();
1202		return -ENODEV;
1203	}
1204	tpg = nacl->se_tpg;
1205	/* scsiInstIndex */
1206	ret = snprintf(page, PAGE_SIZE, "%u\n",
1207			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1208	rcu_read_unlock();
1209	return ret;
1210}
1211
1212static ssize_t target_stat_iport_dev_show(struct config_item *item,
1213		char *page)
1214{
1215	struct se_lun_acl *lacl = iport_to_lacl(item);
1216	struct se_node_acl *nacl = lacl->se_lun_nacl;
1217	struct se_dev_entry *deve;
1218	struct se_lun *lun;
1219	ssize_t ret;
1220
1221	rcu_read_lock();
1222	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1223	if (!deve) {
1224		rcu_read_unlock();
1225		return -ENODEV;
1226	}
1227	lun = rcu_dereference(deve->se_lun);
1228	/* scsiDeviceIndex */
1229	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1230	rcu_read_unlock();
1231	return ret;
1232}
1233
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 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}