Linux Audio

Check our new training course

Loading...
v3.1
   1/*******************************************************************************
   2 * Filename:  target_core_stat.c
   3 *
   4 * Copyright (c) 2011 Rising Tide Systems
   5 * Copyright (c) 2011 Linux-iSCSI.org
   6 *
   7 * Modern ConfigFS group context specific statistics based on original
   8 * target_core_mib.c code
   9 *
  10 * Copyright (c) 2006-2007 SBE, Inc.  All Rights Reserved.
  11 *
  12 * Nicholas A. Bellinger <nab@linux-iscsi.org>
  13 *
  14 * This program is free software; you can redistribute it and/or modify
  15 * it under the terms of the GNU General Public License as published by
  16 * the Free Software Foundation; either version 2 of the License, or
  17 * (at your option) any later version.
  18 *
  19 * This program is distributed in the hope that it will be useful,
  20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 * GNU General Public License for more details.
  23 *
  24 * You should have received a copy of the GNU General Public License
  25 * along with this program; if not, write to the Free Software
  26 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27 *
  28 ******************************************************************************/
  29
  30#include <linux/kernel.h>
  31#include <linux/module.h>
  32#include <linux/delay.h>
  33#include <linux/timer.h>
  34#include <linux/string.h>
  35#include <linux/version.h>
  36#include <generated/utsrelease.h>
  37#include <linux/utsname.h>
  38#include <linux/proc_fs.h>
  39#include <linux/seq_file.h>
  40#include <linux/blkdev.h>
  41#include <linux/configfs.h>
  42#include <scsi/scsi.h>
  43#include <scsi/scsi_device.h>
  44#include <scsi/scsi_host.h>
  45
  46#include <target/target_core_base.h>
  47#include <target/target_core_transport.h>
  48#include <target/target_core_fabric_ops.h>
  49#include <target/target_core_configfs.h>
  50#include <target/configfs_macros.h>
  51
  52#include "target_core_hba.h"
  53
  54#ifndef INITIAL_JIFFIES
  55#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  56#endif
  57
  58#define NONE		"None"
  59#define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
  60
  61#define SCSI_LU_INDEX			1
  62#define LU_COUNT			1
  63
  64/*
  65 * SCSI Device Table
  66 */
  67
  68CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
  69#define DEV_STAT_SCSI_DEV_ATTR(_name, _mode)				\
  70static struct target_stat_scsi_dev_attribute				\
  71			target_stat_scsi_dev_##_name =			\
  72	__CONFIGFS_EATTR(_name, _mode,					\
  73	target_stat_scsi_dev_show_attr_##_name,				\
  74	target_stat_scsi_dev_store_attr_##_name);
  75
  76#define DEV_STAT_SCSI_DEV_ATTR_RO(_name)				\
  77static struct target_stat_scsi_dev_attribute				\
  78			target_stat_scsi_dev_##_name =			\
  79	__CONFIGFS_EATTR_RO(_name,					\
  80	target_stat_scsi_dev_show_attr_##_name);
  81
  82static ssize_t target_stat_scsi_dev_show_attr_inst(
  83	struct se_dev_stat_grps *sgrps, char *page)
  84{
  85	struct se_subsystem_dev *se_subdev = container_of(sgrps,
  86			struct se_subsystem_dev, dev_stat_grps);
  87	struct se_hba *hba = se_subdev->se_dev_hba;
  88	struct se_device *dev = se_subdev->se_dev_ptr;
  89
  90	if (!dev)
  91		return -ENODEV;
  92
  93	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
  94}
  95DEV_STAT_SCSI_DEV_ATTR_RO(inst);
  96
  97static ssize_t target_stat_scsi_dev_show_attr_indx(
  98	struct se_dev_stat_grps *sgrps, char *page)
  99{
 100	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 101			struct se_subsystem_dev, dev_stat_grps);
 102	struct se_device *dev = se_subdev->se_dev_ptr;
 103
 104	if (!dev)
 105		return -ENODEV;
 106
 107	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 108}
 109DEV_STAT_SCSI_DEV_ATTR_RO(indx);
 110
 111static ssize_t target_stat_scsi_dev_show_attr_role(
 112	struct se_dev_stat_grps *sgrps, char *page)
 113{
 114	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 115			struct se_subsystem_dev, dev_stat_grps);
 116	struct se_device *dev = se_subdev->se_dev_ptr;
 117
 118	if (!dev)
 119		return -ENODEV;
 120
 121	return snprintf(page, PAGE_SIZE, "Target\n");
 122}
 123DEV_STAT_SCSI_DEV_ATTR_RO(role);
 124
 125static ssize_t target_stat_scsi_dev_show_attr_ports(
 126	struct se_dev_stat_grps *sgrps, char *page)
 127{
 128	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 129			struct se_subsystem_dev, dev_stat_grps);
 130	struct se_device *dev = se_subdev->se_dev_ptr;
 131
 132	if (!dev)
 133		return -ENODEV;
 134
 135	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
 136}
 137DEV_STAT_SCSI_DEV_ATTR_RO(ports);
 138
 139CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
 140
 141static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
 142	&target_stat_scsi_dev_inst.attr,
 143	&target_stat_scsi_dev_indx.attr,
 144	&target_stat_scsi_dev_role.attr,
 145	&target_stat_scsi_dev_ports.attr,
 146	NULL,
 147};
 148
 149static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
 150	.show_attribute		= target_stat_scsi_dev_attr_show,
 151	.store_attribute	= target_stat_scsi_dev_attr_store,
 152};
 153
 154static struct config_item_type target_stat_scsi_dev_cit = {
 155	.ct_item_ops		= &target_stat_scsi_dev_attrib_ops,
 156	.ct_attrs		= target_stat_scsi_dev_attrs,
 157	.ct_owner		= THIS_MODULE,
 158};
 159
 160/*
 161 * SCSI Target Device Table
 162 */
 163
 164CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
 165#define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode)			\
 166static struct target_stat_scsi_tgt_dev_attribute			\
 167			target_stat_scsi_tgt_dev_##_name =		\
 168	__CONFIGFS_EATTR(_name, _mode,					\
 169	target_stat_scsi_tgt_dev_show_attr_##_name,			\
 170	target_stat_scsi_tgt_dev_store_attr_##_name);
 171
 172#define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name)				\
 173static struct target_stat_scsi_tgt_dev_attribute			\
 174			target_stat_scsi_tgt_dev_##_name =		\
 175	__CONFIGFS_EATTR_RO(_name,					\
 176	target_stat_scsi_tgt_dev_show_attr_##_name);
 177
 178static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
 179	struct se_dev_stat_grps *sgrps, char *page)
 180{
 181	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 182			struct se_subsystem_dev, dev_stat_grps);
 183	struct se_hba *hba = se_subdev->se_dev_hba;
 184	struct se_device *dev = se_subdev->se_dev_ptr;
 185
 186	if (!dev)
 187		return -ENODEV;
 188
 189	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 190}
 191DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
 192
 193static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
 194	struct se_dev_stat_grps *sgrps, char *page)
 195{
 196	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 197			struct se_subsystem_dev, dev_stat_grps);
 198	struct se_device *dev = se_subdev->se_dev_ptr;
 199
 200	if (!dev)
 201		return -ENODEV;
 202
 203	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 204}
 205DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
 206
 207static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
 208	struct se_dev_stat_grps *sgrps, char *page)
 209{
 210	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 211			struct se_subsystem_dev, dev_stat_grps);
 212	struct se_device *dev = se_subdev->se_dev_ptr;
 213
 214	if (!dev)
 215		return -ENODEV;
 216
 217	return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
 218}
 219DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
 220
 221static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
 222	struct se_dev_stat_grps *sgrps, char *page)
 223{
 224	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 225			struct se_subsystem_dev, dev_stat_grps);
 226	struct se_device *dev = se_subdev->se_dev_ptr;
 227	char status[16];
 228
 229	if (!dev)
 230		return -ENODEV;
 231
 232	switch (dev->dev_status) {
 233	case TRANSPORT_DEVICE_ACTIVATED:
 234		strcpy(status, "activated");
 235		break;
 236	case TRANSPORT_DEVICE_DEACTIVATED:
 237		strcpy(status, "deactivated");
 238		break;
 239	case TRANSPORT_DEVICE_SHUTDOWN:
 240		strcpy(status, "shutdown");
 241		break;
 242	case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 243	case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 244		strcpy(status, "offline");
 245		break;
 246	default:
 247		sprintf(status, "unknown(%d)", dev->dev_status);
 248		break;
 249	}
 250
 251	return snprintf(page, PAGE_SIZE, "%s\n", status);
 252}
 253DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
 254
 255static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
 256	struct se_dev_stat_grps *sgrps, char *page)
 257{
 258	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 259			struct se_subsystem_dev, dev_stat_grps);
 260	struct se_device *dev = se_subdev->se_dev_ptr;
 261	int non_accessible_lus;
 262
 263	if (!dev)
 264		return -ENODEV;
 265
 266	switch (dev->dev_status) {
 267	case TRANSPORT_DEVICE_ACTIVATED:
 268		non_accessible_lus = 0;
 269		break;
 270	case TRANSPORT_DEVICE_DEACTIVATED:
 271	case TRANSPORT_DEVICE_SHUTDOWN:
 272	case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 273	case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 274	default:
 275		non_accessible_lus = 1;
 276		break;
 277	}
 278
 279	return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
 280}
 281DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
 282
 283static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
 284	struct se_dev_stat_grps *sgrps, char *page)
 285{
 286	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 287			struct se_subsystem_dev, dev_stat_grps);
 288	struct se_device *dev = se_subdev->se_dev_ptr;
 289
 290	if (!dev)
 291		return -ENODEV;
 292
 293	return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 294}
 295DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
 296
 297
 298CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
 299
 300static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
 301	&target_stat_scsi_tgt_dev_inst.attr,
 302	&target_stat_scsi_tgt_dev_indx.attr,
 303	&target_stat_scsi_tgt_dev_num_lus.attr,
 304	&target_stat_scsi_tgt_dev_status.attr,
 305	&target_stat_scsi_tgt_dev_non_access_lus.attr,
 306	&target_stat_scsi_tgt_dev_resets.attr,
 307	NULL,
 308};
 309
 310static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
 311	.show_attribute		= target_stat_scsi_tgt_dev_attr_show,
 312	.store_attribute	= target_stat_scsi_tgt_dev_attr_store,
 313};
 314
 315static struct config_item_type target_stat_scsi_tgt_dev_cit = {
 316	.ct_item_ops		= &target_stat_scsi_tgt_dev_attrib_ops,
 317	.ct_attrs		= target_stat_scsi_tgt_dev_attrs,
 318	.ct_owner		= THIS_MODULE,
 319};
 320
 321/*
 322 * SCSI Logical Unit Table
 323 */
 324
 325CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
 326#define DEV_STAT_SCSI_LU_ATTR(_name, _mode)				\
 327static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 328	__CONFIGFS_EATTR(_name, _mode,					\
 329	target_stat_scsi_lu_show_attr_##_name,				\
 330	target_stat_scsi_lu_store_attr_##_name);
 331
 332#define DEV_STAT_SCSI_LU_ATTR_RO(_name)					\
 333static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 334	__CONFIGFS_EATTR_RO(_name,					\
 335	target_stat_scsi_lu_show_attr_##_name);
 336
 337static ssize_t target_stat_scsi_lu_show_attr_inst(
 338	struct se_dev_stat_grps *sgrps, char *page)
 339{
 340	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 341			struct se_subsystem_dev, dev_stat_grps);
 342	struct se_hba *hba = se_subdev->se_dev_hba;
 343	struct se_device *dev = se_subdev->se_dev_ptr;
 344
 345	if (!dev)
 346		return -ENODEV;
 347
 348	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 349}
 350DEV_STAT_SCSI_LU_ATTR_RO(inst);
 351
 352static ssize_t target_stat_scsi_lu_show_attr_dev(
 353	struct se_dev_stat_grps *sgrps, char *page)
 354{
 355	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 356			struct se_subsystem_dev, dev_stat_grps);
 357	struct se_device *dev = se_subdev->se_dev_ptr;
 358
 359	if (!dev)
 360		return -ENODEV;
 361
 362	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 363}
 364DEV_STAT_SCSI_LU_ATTR_RO(dev);
 365
 366static ssize_t target_stat_scsi_lu_show_attr_indx(
 367	struct se_dev_stat_grps *sgrps, char *page)
 368{
 369	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 370			struct se_subsystem_dev, dev_stat_grps);
 371	struct se_device *dev = se_subdev->se_dev_ptr;
 372
 373	if (!dev)
 374		return -ENODEV;
 375
 376	return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
 377}
 378DEV_STAT_SCSI_LU_ATTR_RO(indx);
 379
 380static ssize_t target_stat_scsi_lu_show_attr_lun(
 381	struct se_dev_stat_grps *sgrps, char *page)
 382{
 383	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 384			struct se_subsystem_dev, dev_stat_grps);
 385	struct se_device *dev = se_subdev->se_dev_ptr;
 386
 387	if (!dev)
 388		return -ENODEV;
 389	/* FIXME: scsiLuDefaultLun */
 390	return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
 391}
 392DEV_STAT_SCSI_LU_ATTR_RO(lun);
 393
 394static ssize_t target_stat_scsi_lu_show_attr_lu_name(
 395	struct se_dev_stat_grps *sgrps, char *page)
 396{
 397	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 398			struct se_subsystem_dev, dev_stat_grps);
 399	struct se_device *dev = se_subdev->se_dev_ptr;
 400
 401	if (!dev)
 402		return -ENODEV;
 403	/* scsiLuWwnName */
 404	return snprintf(page, PAGE_SIZE, "%s\n",
 405			(strlen(dev->se_sub_dev->t10_wwn.unit_serial)) ?
 406			dev->se_sub_dev->t10_wwn.unit_serial : "None");
 407}
 408DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
 409
 410static ssize_t target_stat_scsi_lu_show_attr_vend(
 411	struct se_dev_stat_grps *sgrps, char *page)
 412{
 413	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 414			struct se_subsystem_dev, dev_stat_grps);
 415	struct se_device *dev = se_subdev->se_dev_ptr;
 416	int i;
 417	char str[sizeof(dev->se_sub_dev->t10_wwn.vendor)+1];
 418
 419	if (!dev)
 420		return -ENODEV;
 421
 422	/* scsiLuVendorId */
 423	for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 424		str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.vendor[i]) ?
 425			dev->se_sub_dev->t10_wwn.vendor[i] : ' ';
 426	str[i] = '\0';
 427	return snprintf(page, PAGE_SIZE, "%s\n", str);
 428}
 429DEV_STAT_SCSI_LU_ATTR_RO(vend);
 430
 431static ssize_t target_stat_scsi_lu_show_attr_prod(
 432	struct se_dev_stat_grps *sgrps, char *page)
 433{
 434	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 435			struct se_subsystem_dev, dev_stat_grps);
 436	struct se_device *dev = se_subdev->se_dev_ptr;
 437	int i;
 438	char str[sizeof(dev->se_sub_dev->t10_wwn.model)+1];
 439
 440	if (!dev)
 441		return -ENODEV;
 442
 443	/* scsiLuProductId */
 444	for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 445		str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.model[i]) ?
 446			dev->se_sub_dev->t10_wwn.model[i] : ' ';
 447	str[i] = '\0';
 448	return snprintf(page, PAGE_SIZE, "%s\n", str);
 449}
 450DEV_STAT_SCSI_LU_ATTR_RO(prod);
 451
 452static ssize_t target_stat_scsi_lu_show_attr_rev(
 453	struct se_dev_stat_grps *sgrps, char *page)
 454{
 455	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 456			struct se_subsystem_dev, dev_stat_grps);
 457	struct se_device *dev = se_subdev->se_dev_ptr;
 458	int i;
 459	char str[sizeof(dev->se_sub_dev->t10_wwn.revision)+1];
 460
 461	if (!dev)
 462		return -ENODEV;
 463
 464	/* scsiLuRevisionId */
 465	for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.revision); i++)
 466		str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.revision[i]) ?
 467			dev->se_sub_dev->t10_wwn.revision[i] : ' ';
 468	str[i] = '\0';
 469	return snprintf(page, PAGE_SIZE, "%s\n", str);
 470}
 471DEV_STAT_SCSI_LU_ATTR_RO(rev);
 472
 473static ssize_t target_stat_scsi_lu_show_attr_dev_type(
 474	struct se_dev_stat_grps *sgrps, char *page)
 475{
 476	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 477			struct se_subsystem_dev, dev_stat_grps);
 478	struct se_device *dev = se_subdev->se_dev_ptr;
 479
 480	if (!dev)
 481		return -ENODEV;
 482
 483	/* scsiLuPeripheralType */
 484	return snprintf(page, PAGE_SIZE, "%u\n",
 485			dev->transport->get_device_type(dev));
 486}
 487DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
 488
 489static ssize_t target_stat_scsi_lu_show_attr_status(
 490	struct se_dev_stat_grps *sgrps, char *page)
 491{
 492	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 493			struct se_subsystem_dev, dev_stat_grps);
 494	struct se_device *dev = se_subdev->se_dev_ptr;
 495
 496	if (!dev)
 497		return -ENODEV;
 498
 499	/* scsiLuStatus */
 500	return snprintf(page, PAGE_SIZE, "%s\n",
 501		(dev->dev_status == TRANSPORT_DEVICE_ACTIVATED) ?
 502		"available" : "notavailable");
 503}
 504DEV_STAT_SCSI_LU_ATTR_RO(status);
 505
 506static ssize_t target_stat_scsi_lu_show_attr_state_bit(
 507	struct se_dev_stat_grps *sgrps, char *page)
 508{
 509	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 510			struct se_subsystem_dev, dev_stat_grps);
 511	struct se_device *dev = se_subdev->se_dev_ptr;
 512
 513	if (!dev)
 514		return -ENODEV;
 515
 516	/* scsiLuState */
 517	return snprintf(page, PAGE_SIZE, "exposed\n");
 518}
 519DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
 520
 521static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
 522	struct se_dev_stat_grps *sgrps, char *page)
 523{
 524	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 525			struct se_subsystem_dev, dev_stat_grps);
 526	struct se_device *dev = se_subdev->se_dev_ptr;
 527
 528	if (!dev)
 529		return -ENODEV;
 530
 531	/* scsiLuNumCommands */
 532	return snprintf(page, PAGE_SIZE, "%llu\n",
 533			(unsigned long long)dev->num_cmds);
 534}
 535DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
 536
 537static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
 538	struct se_dev_stat_grps *sgrps, char *page)
 539{
 540	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 541			struct se_subsystem_dev, dev_stat_grps);
 542	struct se_device *dev = se_subdev->se_dev_ptr;
 543
 544	if (!dev)
 545		return -ENODEV;
 546
 547	/* scsiLuReadMegaBytes */
 548	return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->read_bytes >> 20));
 
 549}
 550DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
 551
 552static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
 553	struct se_dev_stat_grps *sgrps, char *page)
 554{
 555	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 556			struct se_subsystem_dev, dev_stat_grps);
 557	struct se_device *dev = se_subdev->se_dev_ptr;
 558
 559	if (!dev)
 560		return -ENODEV;
 561
 562	/* scsiLuWrittenMegaBytes */
 563	return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->write_bytes >> 20));
 
 564}
 565DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
 566
 567static ssize_t target_stat_scsi_lu_show_attr_resets(
 568	struct se_dev_stat_grps *sgrps, char *page)
 569{
 570	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 571			struct se_subsystem_dev, dev_stat_grps);
 572	struct se_device *dev = se_subdev->se_dev_ptr;
 573
 574	if (!dev)
 575		return -ENODEV;
 576
 577	/* scsiLuInResets */
 578	return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 579}
 580DEV_STAT_SCSI_LU_ATTR_RO(resets);
 581
 582static ssize_t target_stat_scsi_lu_show_attr_full_stat(
 583	struct se_dev_stat_grps *sgrps, char *page)
 584{
 585	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 586			struct se_subsystem_dev, dev_stat_grps);
 587	struct se_device *dev = se_subdev->se_dev_ptr;
 588
 589	if (!dev)
 590		return -ENODEV;
 591
 592	/* FIXME: scsiLuOutTaskSetFullStatus */
 593	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 594}
 595DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
 596
 597static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
 598	struct se_dev_stat_grps *sgrps, char *page)
 599{
 600	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 601			struct se_subsystem_dev, dev_stat_grps);
 602	struct se_device *dev = se_subdev->se_dev_ptr;
 603
 604	if (!dev)
 605		return -ENODEV;
 606
 607	/* FIXME: scsiLuHSInCommands */
 608	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 609}
 610DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
 611
 612static ssize_t target_stat_scsi_lu_show_attr_creation_time(
 613	struct se_dev_stat_grps *sgrps, char *page)
 614{
 615	struct se_subsystem_dev *se_subdev = container_of(sgrps,
 616			struct se_subsystem_dev, dev_stat_grps);
 617	struct se_device *dev = se_subdev->se_dev_ptr;
 618
 619	if (!dev)
 620		return -ENODEV;
 621
 622	/* scsiLuCreationTime */
 623	return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
 624				INITIAL_JIFFIES) * 100 / HZ));
 625}
 626DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
 627
 628CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
 629
 630static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
 631	&target_stat_scsi_lu_inst.attr,
 632	&target_stat_scsi_lu_dev.attr,
 633	&target_stat_scsi_lu_indx.attr,
 634	&target_stat_scsi_lu_lun.attr,
 635	&target_stat_scsi_lu_lu_name.attr,
 636	&target_stat_scsi_lu_vend.attr,
 637	&target_stat_scsi_lu_prod.attr,
 638	&target_stat_scsi_lu_rev.attr,
 639	&target_stat_scsi_lu_dev_type.attr,
 640	&target_stat_scsi_lu_status.attr,
 641	&target_stat_scsi_lu_state_bit.attr,
 642	&target_stat_scsi_lu_num_cmds.attr,
 643	&target_stat_scsi_lu_read_mbytes.attr,
 644	&target_stat_scsi_lu_write_mbytes.attr,
 645	&target_stat_scsi_lu_resets.attr,
 646	&target_stat_scsi_lu_full_stat.attr,
 647	&target_stat_scsi_lu_hs_num_cmds.attr,
 648	&target_stat_scsi_lu_creation_time.attr,
 649	NULL,
 650};
 651
 652static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
 653	.show_attribute		= target_stat_scsi_lu_attr_show,
 654	.store_attribute	= target_stat_scsi_lu_attr_store,
 655};
 656
 657static struct config_item_type target_stat_scsi_lu_cit = {
 658	.ct_item_ops		= &target_stat_scsi_lu_attrib_ops,
 659	.ct_attrs		= target_stat_scsi_lu_attrs,
 660	.ct_owner		= THIS_MODULE,
 661};
 662
 663/*
 664 * Called from target_core_configfs.c:target_core_make_subdev() to setup
 665 * the target statistics groups + configfs CITs located in target_core_stat.c
 666 */
 667void target_stat_setup_dev_default_groups(struct se_subsystem_dev *se_subdev)
 668{
 669	struct config_group *dev_stat_grp = &se_subdev->dev_stat_grps.stat_group;
 670
 671	config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_dev_group,
 672			"scsi_dev", &target_stat_scsi_dev_cit);
 673	config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_tgt_dev_group,
 674			"scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 675	config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_lu_group,
 676			"scsi_lu", &target_stat_scsi_lu_cit);
 677
 678	dev_stat_grp->default_groups[0] = &se_subdev->dev_stat_grps.scsi_dev_group;
 679	dev_stat_grp->default_groups[1] = &se_subdev->dev_stat_grps.scsi_tgt_dev_group;
 680	dev_stat_grp->default_groups[2] = &se_subdev->dev_stat_grps.scsi_lu_group;
 681	dev_stat_grp->default_groups[3] = NULL;
 682}
 683
 684/*
 685 * SCSI Port Table
 686 */
 687
 688CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
 689#define DEV_STAT_SCSI_PORT_ATTR(_name, _mode)				\
 690static struct target_stat_scsi_port_attribute				\
 691			target_stat_scsi_port_##_name =			\
 692	__CONFIGFS_EATTR(_name, _mode,					\
 693	target_stat_scsi_port_show_attr_##_name,			\
 694	target_stat_scsi_port_store_attr_##_name);
 695
 696#define DEV_STAT_SCSI_PORT_ATTR_RO(_name)				\
 697static struct target_stat_scsi_port_attribute				\
 698			target_stat_scsi_port_##_name =			\
 699	__CONFIGFS_EATTR_RO(_name,					\
 700	target_stat_scsi_port_show_attr_##_name);
 701
 702static ssize_t target_stat_scsi_port_show_attr_inst(
 703	struct se_port_stat_grps *pgrps, char *page)
 704{
 705	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 706	struct se_port *sep;
 707	struct se_device *dev = lun->lun_se_dev;
 708	struct se_hba *hba;
 709	ssize_t ret;
 710
 711	spin_lock(&lun->lun_sep_lock);
 712	sep = lun->lun_sep;
 713	if (!sep) {
 714		spin_unlock(&lun->lun_sep_lock);
 715		return -ENODEV;
 716	}
 717	hba = dev->se_hba;
 718	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 719	spin_unlock(&lun->lun_sep_lock);
 720	return ret;
 721}
 722DEV_STAT_SCSI_PORT_ATTR_RO(inst);
 723
 724static ssize_t target_stat_scsi_port_show_attr_dev(
 725	struct se_port_stat_grps *pgrps, char *page)
 726{
 727	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 728	struct se_port *sep;
 729	struct se_device *dev = lun->lun_se_dev;
 730	ssize_t ret;
 731
 732	spin_lock(&lun->lun_sep_lock);
 733	sep = lun->lun_sep;
 734	if (!sep) {
 735		spin_unlock(&lun->lun_sep_lock);
 736		return -ENODEV;
 737	}
 738	ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 739	spin_unlock(&lun->lun_sep_lock);
 740	return ret;
 741}
 742DEV_STAT_SCSI_PORT_ATTR_RO(dev);
 743
 744static ssize_t target_stat_scsi_port_show_attr_indx(
 745	struct se_port_stat_grps *pgrps, char *page)
 746{
 747	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 748	struct se_port *sep;
 749	ssize_t ret;
 750
 751	spin_lock(&lun->lun_sep_lock);
 752	sep = lun->lun_sep;
 753	if (!sep) {
 754		spin_unlock(&lun->lun_sep_lock);
 755		return -ENODEV;
 756	}
 757	ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 758	spin_unlock(&lun->lun_sep_lock);
 759	return ret;
 760}
 761DEV_STAT_SCSI_PORT_ATTR_RO(indx);
 762
 763static ssize_t target_stat_scsi_port_show_attr_role(
 764	struct se_port_stat_grps *pgrps, char *page)
 765{
 766	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 767	struct se_device *dev = lun->lun_se_dev;
 768	struct se_port *sep;
 769	ssize_t ret;
 770
 771	if (!dev)
 772		return -ENODEV;
 773
 774	spin_lock(&lun->lun_sep_lock);
 775	sep = lun->lun_sep;
 776	if (!sep) {
 777		spin_unlock(&lun->lun_sep_lock);
 778		return -ENODEV;
 779	}
 780	ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 781	spin_unlock(&lun->lun_sep_lock);
 782	return ret;
 783}
 784DEV_STAT_SCSI_PORT_ATTR_RO(role);
 785
 786static ssize_t target_stat_scsi_port_show_attr_busy_count(
 787	struct se_port_stat_grps *pgrps, char *page)
 788{
 789	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 790	struct se_port *sep;
 791	ssize_t ret;
 792
 793	spin_lock(&lun->lun_sep_lock);
 794	sep = lun->lun_sep;
 795	if (!sep) {
 796		spin_unlock(&lun->lun_sep_lock);
 797		return -ENODEV;
 798	}
 799	/* FIXME: scsiPortBusyStatuses  */
 800	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 801	spin_unlock(&lun->lun_sep_lock);
 802	return ret;
 803}
 804DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
 805
 806CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
 807
 808static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 809	&target_stat_scsi_port_inst.attr,
 810	&target_stat_scsi_port_dev.attr,
 811	&target_stat_scsi_port_indx.attr,
 812	&target_stat_scsi_port_role.attr,
 813	&target_stat_scsi_port_busy_count.attr,
 814	NULL,
 815};
 816
 817static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
 818	.show_attribute		= target_stat_scsi_port_attr_show,
 819	.store_attribute	= target_stat_scsi_port_attr_store,
 820};
 821
 822static struct config_item_type target_stat_scsi_port_cit = {
 823	.ct_item_ops		= &target_stat_scsi_port_attrib_ops,
 824	.ct_attrs		= target_stat_scsi_port_attrs,
 825	.ct_owner		= THIS_MODULE,
 826};
 827
 828/*
 829 * SCSI Target Port Table
 830 */
 831CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
 832#define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode)			\
 833static struct target_stat_scsi_tgt_port_attribute			\
 834			target_stat_scsi_tgt_port_##_name =		\
 835	__CONFIGFS_EATTR(_name, _mode,					\
 836	target_stat_scsi_tgt_port_show_attr_##_name,			\
 837	target_stat_scsi_tgt_port_store_attr_##_name);
 838
 839#define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name)				\
 840static struct target_stat_scsi_tgt_port_attribute			\
 841			target_stat_scsi_tgt_port_##_name =		\
 842	__CONFIGFS_EATTR_RO(_name,					\
 843	target_stat_scsi_tgt_port_show_attr_##_name);
 844
 845static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
 846	struct se_port_stat_grps *pgrps, char *page)
 847{
 848	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 849	struct se_device *dev = lun->lun_se_dev;
 850	struct se_port *sep;
 851	struct se_hba *hba;
 852	ssize_t ret;
 853
 854	spin_lock(&lun->lun_sep_lock);
 855	sep = lun->lun_sep;
 856	if (!sep) {
 857		spin_unlock(&lun->lun_sep_lock);
 858		return -ENODEV;
 859	}
 860	hba = dev->se_hba;
 861	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 862	spin_unlock(&lun->lun_sep_lock);
 863	return ret;
 864}
 865DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
 866
 867static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
 868	struct se_port_stat_grps *pgrps, char *page)
 869{
 870	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 871	struct se_device *dev = lun->lun_se_dev;
 872	struct se_port *sep;
 873	ssize_t ret;
 874
 875	spin_lock(&lun->lun_sep_lock);
 876	sep = lun->lun_sep;
 877	if (!sep) {
 878		spin_unlock(&lun->lun_sep_lock);
 879		return -ENODEV;
 880	}
 881	ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 882	spin_unlock(&lun->lun_sep_lock);
 883	return ret;
 884}
 885DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
 886
 887static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
 888	struct se_port_stat_grps *pgrps, char *page)
 889{
 890	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 891	struct se_port *sep;
 892	ssize_t ret;
 893
 894	spin_lock(&lun->lun_sep_lock);
 895	sep = lun->lun_sep;
 896	if (!sep) {
 897		spin_unlock(&lun->lun_sep_lock);
 898		return -ENODEV;
 899	}
 900	ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 901	spin_unlock(&lun->lun_sep_lock);
 902	return ret;
 903}
 904DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
 905
 906static ssize_t target_stat_scsi_tgt_port_show_attr_name(
 907	struct se_port_stat_grps *pgrps, char *page)
 908{
 909	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 910	struct se_port *sep;
 911	struct se_portal_group *tpg;
 912	ssize_t ret;
 913
 914	spin_lock(&lun->lun_sep_lock);
 915	sep = lun->lun_sep;
 916	if (!sep) {
 917		spin_unlock(&lun->lun_sep_lock);
 918		return -ENODEV;
 919	}
 920	tpg = sep->sep_tpg;
 921
 922	ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 923		tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
 924	spin_unlock(&lun->lun_sep_lock);
 925	return ret;
 926}
 927DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
 928
 929static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
 930	struct se_port_stat_grps *pgrps, char *page)
 931{
 932	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 933	struct se_port *sep;
 934	struct se_portal_group *tpg;
 935	ssize_t ret;
 936
 937	spin_lock(&lun->lun_sep_lock);
 938	sep = lun->lun_sep;
 939	if (!sep) {
 940		spin_unlock(&lun->lun_sep_lock);
 941		return -ENODEV;
 942	}
 943	tpg = sep->sep_tpg;
 944
 945	ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 946		tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 947		tpg->se_tpg_tfo->tpg_get_tag(tpg));
 948	spin_unlock(&lun->lun_sep_lock);
 949	return ret;
 950}
 951DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
 952
 953static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
 954	struct se_port_stat_grps *pgrps, char *page)
 955{
 956	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 957	struct se_port *sep;
 958	struct se_portal_group *tpg;
 959	ssize_t ret;
 960
 961	spin_lock(&lun->lun_sep_lock);
 962	sep = lun->lun_sep;
 963	if (!sep) {
 964		spin_unlock(&lun->lun_sep_lock);
 965		return -ENODEV;
 966	}
 967	tpg = sep->sep_tpg;
 968
 969	ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
 970	spin_unlock(&lun->lun_sep_lock);
 971	return ret;
 972}
 973DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
 974
 975static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
 976	struct se_port_stat_grps *pgrps, char *page)
 977{
 978	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 979	struct se_port *sep;
 980	struct se_portal_group *tpg;
 981	ssize_t ret;
 982
 983	spin_lock(&lun->lun_sep_lock);
 984	sep = lun->lun_sep;
 985	if (!sep) {
 986		spin_unlock(&lun->lun_sep_lock);
 987		return -ENODEV;
 988	}
 989	tpg = sep->sep_tpg;
 990
 991	ret = snprintf(page, PAGE_SIZE, "%u\n",
 992			(u32)(sep->sep_stats.rx_data_octets >> 20));
 993	spin_unlock(&lun->lun_sep_lock);
 994	return ret;
 995}
 996DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
 997
 998static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
 999	struct se_port_stat_grps *pgrps, char *page)
1000{
1001	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1002	struct se_port *sep;
1003	struct se_portal_group *tpg;
1004	ssize_t ret;
1005
1006	spin_lock(&lun->lun_sep_lock);
1007	sep = lun->lun_sep;
1008	if (!sep) {
1009		spin_unlock(&lun->lun_sep_lock);
1010		return -ENODEV;
1011	}
1012	tpg = sep->sep_tpg;
1013
1014	ret = snprintf(page, PAGE_SIZE, "%u\n",
1015			(u32)(sep->sep_stats.tx_data_octets >> 20));
1016	spin_unlock(&lun->lun_sep_lock);
1017	return ret;
1018}
1019DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
1020
1021static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
1022	struct se_port_stat_grps *pgrps, char *page)
1023{
1024	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1025	struct se_port *sep;
1026	struct se_portal_group *tpg;
1027	ssize_t ret;
1028
1029	spin_lock(&lun->lun_sep_lock);
1030	sep = lun->lun_sep;
1031	if (!sep) {
1032		spin_unlock(&lun->lun_sep_lock);
1033		return -ENODEV;
1034	}
1035	tpg = sep->sep_tpg;
1036
1037	/* FIXME: scsiTgtPortHsInCommands */
1038	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1039	spin_unlock(&lun->lun_sep_lock);
1040	return ret;
1041}
1042DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
1043
1044CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
1045		scsi_tgt_port_group);
1046
1047static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
1048	&target_stat_scsi_tgt_port_inst.attr,
1049	&target_stat_scsi_tgt_port_dev.attr,
1050	&target_stat_scsi_tgt_port_indx.attr,
1051	&target_stat_scsi_tgt_port_name.attr,
1052	&target_stat_scsi_tgt_port_port_index.attr,
1053	&target_stat_scsi_tgt_port_in_cmds.attr,
1054	&target_stat_scsi_tgt_port_write_mbytes.attr,
1055	&target_stat_scsi_tgt_port_read_mbytes.attr,
1056	&target_stat_scsi_tgt_port_hs_in_cmds.attr,
1057	NULL,
1058};
1059
1060static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
1061	.show_attribute		= target_stat_scsi_tgt_port_attr_show,
1062	.store_attribute	= target_stat_scsi_tgt_port_attr_store,
1063};
1064
1065static struct config_item_type target_stat_scsi_tgt_port_cit = {
1066	.ct_item_ops		= &target_stat_scsi_tgt_port_attrib_ops,
1067	.ct_attrs		= target_stat_scsi_tgt_port_attrs,
1068	.ct_owner		= THIS_MODULE,
1069};
1070
1071/*
1072 * SCSI Transport Table
1073o */
1074
1075CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
1076#define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode)			\
1077static struct target_stat_scsi_transport_attribute			\
1078			target_stat_scsi_transport_##_name =		\
1079	__CONFIGFS_EATTR(_name, _mode,					\
1080	target_stat_scsi_transport_show_attr_##_name,			\
1081	target_stat_scsi_transport_store_attr_##_name);
1082
1083#define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name)				\
1084static struct target_stat_scsi_transport_attribute			\
1085			target_stat_scsi_transport_##_name =		\
1086	__CONFIGFS_EATTR_RO(_name,					\
1087	target_stat_scsi_transport_show_attr_##_name);
1088
1089static ssize_t target_stat_scsi_transport_show_attr_inst(
1090	struct se_port_stat_grps *pgrps, char *page)
1091{
1092	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1093	struct se_device *dev = lun->lun_se_dev;
1094	struct se_port *sep;
1095	struct se_hba *hba;
1096	ssize_t ret;
1097
1098	spin_lock(&lun->lun_sep_lock);
1099	sep = lun->lun_sep;
1100	if (!sep) {
1101		spin_unlock(&lun->lun_sep_lock);
1102		return -ENODEV;
1103	}
1104
1105	hba = dev->se_hba;
1106	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
1107	spin_unlock(&lun->lun_sep_lock);
1108	return ret;
1109}
1110DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
1111
1112static ssize_t target_stat_scsi_transport_show_attr_device(
1113	struct se_port_stat_grps *pgrps, char *page)
1114{
1115	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1116	struct se_port *sep;
1117	struct se_portal_group *tpg;
1118	ssize_t ret;
1119
1120	spin_lock(&lun->lun_sep_lock);
1121	sep = lun->lun_sep;
1122	if (!sep) {
1123		spin_unlock(&lun->lun_sep_lock);
1124		return -ENODEV;
1125	}
1126	tpg = sep->sep_tpg;
1127	/* scsiTransportType */
1128	ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
1129			tpg->se_tpg_tfo->get_fabric_name());
1130	spin_unlock(&lun->lun_sep_lock);
1131	return ret;
1132}
1133DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
1134
1135static ssize_t target_stat_scsi_transport_show_attr_indx(
1136	struct se_port_stat_grps *pgrps, char *page)
1137{
1138	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1139	struct se_port *sep;
1140	struct se_portal_group *tpg;
1141	ssize_t ret;
1142
1143	spin_lock(&lun->lun_sep_lock);
1144	sep = lun->lun_sep;
1145	if (!sep) {
1146		spin_unlock(&lun->lun_sep_lock);
1147		return -ENODEV;
1148	}
1149	tpg = sep->sep_tpg;
1150	ret = snprintf(page, PAGE_SIZE, "%u\n",
1151			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1152	spin_unlock(&lun->lun_sep_lock);
1153	return ret;
1154}
1155DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
1156
1157static ssize_t target_stat_scsi_transport_show_attr_dev_name(
1158	struct se_port_stat_grps *pgrps, char *page)
1159{
1160	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1161	struct se_device *dev = lun->lun_se_dev;
1162	struct se_port *sep;
1163	struct se_portal_group *tpg;
1164	struct t10_wwn *wwn;
1165	ssize_t ret;
1166
1167	spin_lock(&lun->lun_sep_lock);
1168	sep = lun->lun_sep;
1169	if (!sep) {
1170		spin_unlock(&lun->lun_sep_lock);
1171		return -ENODEV;
1172	}
1173	tpg = sep->sep_tpg;
1174	wwn = &dev->se_sub_dev->t10_wwn;
1175	/* scsiTransportDevName */
1176	ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1177			tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1178			(strlen(wwn->unit_serial)) ? wwn->unit_serial :
1179			wwn->vendor);
1180	spin_unlock(&lun->lun_sep_lock);
1181	return ret;
1182}
1183DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1184
1185CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1186		scsi_transport_group);
1187
1188static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1189	&target_stat_scsi_transport_inst.attr,
1190	&target_stat_scsi_transport_device.attr,
1191	&target_stat_scsi_transport_indx.attr,
1192	&target_stat_scsi_transport_dev_name.attr,
1193	NULL,
1194};
1195
1196static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1197	.show_attribute		= target_stat_scsi_transport_attr_show,
1198	.store_attribute	= target_stat_scsi_transport_attr_store,
1199};
1200
1201static struct config_item_type target_stat_scsi_transport_cit = {
1202	.ct_item_ops		= &target_stat_scsi_transport_attrib_ops,
1203	.ct_attrs		= target_stat_scsi_transport_attrs,
1204	.ct_owner		= THIS_MODULE,
1205};
1206
1207/*
1208 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1209 * the target port statistics groups + configfs CITs located in target_core_stat.c
1210 */
1211void target_stat_setup_port_default_groups(struct se_lun *lun)
1212{
1213	struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1214
1215	config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1216			"scsi_port", &target_stat_scsi_port_cit);
1217	config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1218			"scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1219	config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1220			"scsi_transport", &target_stat_scsi_transport_cit);
1221
1222	port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1223	port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1224	port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1225	port_stat_grp->default_groups[3] = NULL;
1226}
1227
1228/*
1229 * SCSI Authorized Initiator Table
1230 */
1231
1232CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1233#define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode)			\
1234static struct target_stat_scsi_auth_intr_attribute			\
1235			target_stat_scsi_auth_intr_##_name =		\
1236	__CONFIGFS_EATTR(_name, _mode,					\
1237	target_stat_scsi_auth_intr_show_attr_##_name,			\
1238	target_stat_scsi_auth_intr_store_attr_##_name);
1239
1240#define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name)				\
1241static struct target_stat_scsi_auth_intr_attribute			\
1242			target_stat_scsi_auth_intr_##_name =		\
1243	__CONFIGFS_EATTR_RO(_name,					\
1244	target_stat_scsi_auth_intr_show_attr_##_name);
1245
1246static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1247	struct se_ml_stat_grps *lgrps, char *page)
1248{
1249	struct se_lun_acl *lacl = container_of(lgrps,
1250			struct se_lun_acl, ml_stat_grps);
1251	struct se_node_acl *nacl = lacl->se_lun_nacl;
1252	struct se_dev_entry *deve;
1253	struct se_portal_group *tpg;
1254	ssize_t ret;
1255
1256	spin_lock_irq(&nacl->device_list_lock);
1257	deve = &nacl->device_list[lacl->mapped_lun];
1258	if (!deve->se_lun || !deve->se_lun_acl) {
1259		spin_unlock_irq(&nacl->device_list_lock);
1260		return -ENODEV;
1261	}
1262	tpg = nacl->se_tpg;
1263	/* scsiInstIndex */
1264	ret = snprintf(page, PAGE_SIZE, "%u\n",
1265			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1266	spin_unlock_irq(&nacl->device_list_lock);
1267	return ret;
1268}
1269DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1270
1271static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1272	struct se_ml_stat_grps *lgrps, char *page)
1273{
1274	struct se_lun_acl *lacl = container_of(lgrps,
1275			struct se_lun_acl, ml_stat_grps);
1276	struct se_node_acl *nacl = lacl->se_lun_nacl;
1277	struct se_dev_entry *deve;
1278	struct se_lun *lun;
1279	struct se_portal_group *tpg;
1280	ssize_t ret;
1281
1282	spin_lock_irq(&nacl->device_list_lock);
1283	deve = &nacl->device_list[lacl->mapped_lun];
1284	if (!deve->se_lun || !deve->se_lun_acl) {
1285		spin_unlock_irq(&nacl->device_list_lock);
1286		return -ENODEV;
1287	}
1288	tpg = nacl->se_tpg;
1289	lun = deve->se_lun;
1290	/* scsiDeviceIndex */
1291	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1292	spin_unlock_irq(&nacl->device_list_lock);
1293	return ret;
1294}
1295DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1296
1297static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1298	struct se_ml_stat_grps *lgrps, char *page)
1299{
1300	struct se_lun_acl *lacl = container_of(lgrps,
1301			struct se_lun_acl, ml_stat_grps);
1302	struct se_node_acl *nacl = lacl->se_lun_nacl;
1303	struct se_dev_entry *deve;
1304	struct se_portal_group *tpg;
1305	ssize_t ret;
1306
1307	spin_lock_irq(&nacl->device_list_lock);
1308	deve = &nacl->device_list[lacl->mapped_lun];
1309	if (!deve->se_lun || !deve->se_lun_acl) {
1310		spin_unlock_irq(&nacl->device_list_lock);
1311		return -ENODEV;
1312	}
1313	tpg = nacl->se_tpg;
1314	/* scsiAuthIntrTgtPortIndex */
1315	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1316	spin_unlock_irq(&nacl->device_list_lock);
1317	return ret;
1318}
1319DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1320
1321static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1322	struct se_ml_stat_grps *lgrps, char *page)
1323{
1324	struct se_lun_acl *lacl = container_of(lgrps,
1325			struct se_lun_acl, ml_stat_grps);
1326	struct se_node_acl *nacl = lacl->se_lun_nacl;
1327	struct se_dev_entry *deve;
1328	ssize_t ret;
1329
1330	spin_lock_irq(&nacl->device_list_lock);
1331	deve = &nacl->device_list[lacl->mapped_lun];
1332	if (!deve->se_lun || !deve->se_lun_acl) {
1333		spin_unlock_irq(&nacl->device_list_lock);
1334		return -ENODEV;
1335	}
1336	/* scsiAuthIntrIndex */
1337	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1338	spin_unlock_irq(&nacl->device_list_lock);
1339	return ret;
1340}
1341DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1342
1343static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1344	struct se_ml_stat_grps *lgrps, char *page)
1345{
1346	struct se_lun_acl *lacl = container_of(lgrps,
1347			struct se_lun_acl, ml_stat_grps);
1348	struct se_node_acl *nacl = lacl->se_lun_nacl;
1349	struct se_dev_entry *deve;
1350	ssize_t ret;
1351
1352	spin_lock_irq(&nacl->device_list_lock);
1353	deve = &nacl->device_list[lacl->mapped_lun];
1354	if (!deve->se_lun || !deve->se_lun_acl) {
1355		spin_unlock_irq(&nacl->device_list_lock);
1356		return -ENODEV;
1357	}
1358	/* scsiAuthIntrDevOrPort */
1359	ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1360	spin_unlock_irq(&nacl->device_list_lock);
1361	return ret;
1362}
1363DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1364
1365static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1366	struct se_ml_stat_grps *lgrps, char *page)
1367{
1368	struct se_lun_acl *lacl = container_of(lgrps,
1369			struct se_lun_acl, ml_stat_grps);
1370	struct se_node_acl *nacl = lacl->se_lun_nacl;
1371	struct se_dev_entry *deve;
1372	ssize_t ret;
1373
1374	spin_lock_irq(&nacl->device_list_lock);
1375	deve = &nacl->device_list[lacl->mapped_lun];
1376	if (!deve->se_lun || !deve->se_lun_acl) {
1377		spin_unlock_irq(&nacl->device_list_lock);
1378		return -ENODEV;
1379	}
1380	/* scsiAuthIntrName */
1381	ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1382	spin_unlock_irq(&nacl->device_list_lock);
1383	return ret;
1384}
1385DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1386
1387static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1388	struct se_ml_stat_grps *lgrps, char *page)
1389{
1390	struct se_lun_acl *lacl = container_of(lgrps,
1391			struct se_lun_acl, ml_stat_grps);
1392	struct se_node_acl *nacl = lacl->se_lun_nacl;
1393	struct se_dev_entry *deve;
1394	ssize_t ret;
1395
1396	spin_lock_irq(&nacl->device_list_lock);
1397	deve = &nacl->device_list[lacl->mapped_lun];
1398	if (!deve->se_lun || !deve->se_lun_acl) {
1399		spin_unlock_irq(&nacl->device_list_lock);
1400		return -ENODEV;
1401	}
1402	/* FIXME: scsiAuthIntrLunMapIndex */
1403	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1404	spin_unlock_irq(&nacl->device_list_lock);
1405	return ret;
1406}
1407DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1408
1409static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1410	struct se_ml_stat_grps *lgrps, char *page)
1411{
1412	struct se_lun_acl *lacl = container_of(lgrps,
1413			struct se_lun_acl, ml_stat_grps);
1414	struct se_node_acl *nacl = lacl->se_lun_nacl;
1415	struct se_dev_entry *deve;
1416	ssize_t ret;
1417
1418	spin_lock_irq(&nacl->device_list_lock);
1419	deve = &nacl->device_list[lacl->mapped_lun];
1420	if (!deve->se_lun || !deve->se_lun_acl) {
1421		spin_unlock_irq(&nacl->device_list_lock);
1422		return -ENODEV;
1423	}
1424	/* scsiAuthIntrAttachedTimes */
1425	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1426	spin_unlock_irq(&nacl->device_list_lock);
1427	return ret;
1428}
1429DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1430
1431static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1432	struct se_ml_stat_grps *lgrps, char *page)
1433{
1434	struct se_lun_acl *lacl = container_of(lgrps,
1435			struct se_lun_acl, ml_stat_grps);
1436	struct se_node_acl *nacl = lacl->se_lun_nacl;
1437	struct se_dev_entry *deve;
1438	ssize_t ret;
1439
1440	spin_lock_irq(&nacl->device_list_lock);
1441	deve = &nacl->device_list[lacl->mapped_lun];
1442	if (!deve->se_lun || !deve->se_lun_acl) {
1443		spin_unlock_irq(&nacl->device_list_lock);
1444		return -ENODEV;
1445	}
1446	/* scsiAuthIntrOutCommands */
1447	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1448	spin_unlock_irq(&nacl->device_list_lock);
1449	return ret;
1450}
1451DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1452
1453static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1454	struct se_ml_stat_grps *lgrps, char *page)
1455{
1456	struct se_lun_acl *lacl = container_of(lgrps,
1457			struct se_lun_acl, ml_stat_grps);
1458	struct se_node_acl *nacl = lacl->se_lun_nacl;
1459	struct se_dev_entry *deve;
1460	ssize_t ret;
1461
1462	spin_lock_irq(&nacl->device_list_lock);
1463	deve = &nacl->device_list[lacl->mapped_lun];
1464	if (!deve->se_lun || !deve->se_lun_acl) {
1465		spin_unlock_irq(&nacl->device_list_lock);
1466		return -ENODEV;
1467	}
1468	/* scsiAuthIntrReadMegaBytes */
1469	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1470	spin_unlock_irq(&nacl->device_list_lock);
1471	return ret;
1472}
1473DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1474
1475static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1476	struct se_ml_stat_grps *lgrps, char *page)
1477{
1478	struct se_lun_acl *lacl = container_of(lgrps,
1479			struct se_lun_acl, ml_stat_grps);
1480	struct se_node_acl *nacl = lacl->se_lun_nacl;
1481	struct se_dev_entry *deve;
1482	ssize_t ret;
1483
1484	spin_lock_irq(&nacl->device_list_lock);
1485	deve = &nacl->device_list[lacl->mapped_lun];
1486	if (!deve->se_lun || !deve->se_lun_acl) {
1487		spin_unlock_irq(&nacl->device_list_lock);
1488		return -ENODEV;
1489	}
1490	/* scsiAuthIntrWrittenMegaBytes */
1491	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1492	spin_unlock_irq(&nacl->device_list_lock);
1493	return ret;
1494}
1495DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1496
1497static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1498	struct se_ml_stat_grps *lgrps, char *page)
1499{
1500	struct se_lun_acl *lacl = container_of(lgrps,
1501			struct se_lun_acl, ml_stat_grps);
1502	struct se_node_acl *nacl = lacl->se_lun_nacl;
1503	struct se_dev_entry *deve;
1504	ssize_t ret;
1505
1506	spin_lock_irq(&nacl->device_list_lock);
1507	deve = &nacl->device_list[lacl->mapped_lun];
1508	if (!deve->se_lun || !deve->se_lun_acl) {
1509		spin_unlock_irq(&nacl->device_list_lock);
1510		return -ENODEV;
1511	}
1512	/* FIXME: scsiAuthIntrHSOutCommands */
1513	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1514	spin_unlock_irq(&nacl->device_list_lock);
1515	return ret;
1516}
1517DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1518
1519static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1520	struct se_ml_stat_grps *lgrps, char *page)
1521{
1522	struct se_lun_acl *lacl = container_of(lgrps,
1523			struct se_lun_acl, ml_stat_grps);
1524	struct se_node_acl *nacl = lacl->se_lun_nacl;
1525	struct se_dev_entry *deve;
1526	ssize_t ret;
1527
1528	spin_lock_irq(&nacl->device_list_lock);
1529	deve = &nacl->device_list[lacl->mapped_lun];
1530	if (!deve->se_lun || !deve->se_lun_acl) {
1531		spin_unlock_irq(&nacl->device_list_lock);
1532		return -ENODEV;
1533	}
1534	/* scsiAuthIntrLastCreation */
1535	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1536				INITIAL_JIFFIES) * 100 / HZ));
1537	spin_unlock_irq(&nacl->device_list_lock);
1538	return ret;
1539}
1540DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1541
1542static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1543	struct se_ml_stat_grps *lgrps, char *page)
1544{
1545	struct se_lun_acl *lacl = container_of(lgrps,
1546			struct se_lun_acl, ml_stat_grps);
1547	struct se_node_acl *nacl = lacl->se_lun_nacl;
1548	struct se_dev_entry *deve;
1549	ssize_t ret;
1550
1551	spin_lock_irq(&nacl->device_list_lock);
1552	deve = &nacl->device_list[lacl->mapped_lun];
1553	if (!deve->se_lun || !deve->se_lun_acl) {
1554		spin_unlock_irq(&nacl->device_list_lock);
1555		return -ENODEV;
1556	}
1557	/* FIXME: scsiAuthIntrRowStatus */
1558	ret = snprintf(page, PAGE_SIZE, "Ready\n");
1559	spin_unlock_irq(&nacl->device_list_lock);
1560	return ret;
1561}
1562DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1563
1564CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1565		scsi_auth_intr_group);
1566
1567static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1568	&target_stat_scsi_auth_intr_inst.attr,
1569	&target_stat_scsi_auth_intr_dev.attr,
1570	&target_stat_scsi_auth_intr_port.attr,
1571	&target_stat_scsi_auth_intr_indx.attr,
1572	&target_stat_scsi_auth_intr_dev_or_port.attr,
1573	&target_stat_scsi_auth_intr_intr_name.attr,
1574	&target_stat_scsi_auth_intr_map_indx.attr,
1575	&target_stat_scsi_auth_intr_att_count.attr,
1576	&target_stat_scsi_auth_intr_num_cmds.attr,
1577	&target_stat_scsi_auth_intr_read_mbytes.attr,
1578	&target_stat_scsi_auth_intr_write_mbytes.attr,
1579	&target_stat_scsi_auth_intr_hs_num_cmds.attr,
1580	&target_stat_scsi_auth_intr_creation_time.attr,
1581	&target_stat_scsi_auth_intr_row_status.attr,
1582	NULL,
1583};
1584
1585static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1586	.show_attribute		= target_stat_scsi_auth_intr_attr_show,
1587	.store_attribute	= target_stat_scsi_auth_intr_attr_store,
1588};
1589
1590static struct config_item_type target_stat_scsi_auth_intr_cit = {
1591	.ct_item_ops		= &target_stat_scsi_auth_intr_attrib_ops,
1592	.ct_attrs		= target_stat_scsi_auth_intr_attrs,
1593	.ct_owner		= THIS_MODULE,
1594};
1595
1596/*
1597 * SCSI Attached Initiator Port Table
1598 */
1599
1600CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1601#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode)			\
1602static struct target_stat_scsi_att_intr_port_attribute			\
1603		target_stat_scsi_att_intr_port_##_name =		\
1604	__CONFIGFS_EATTR(_name, _mode,					\
1605	target_stat_scsi_att_intr_port_show_attr_##_name,		\
1606	target_stat_scsi_att_intr_port_store_attr_##_name);
1607
1608#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name)			\
1609static struct target_stat_scsi_att_intr_port_attribute			\
1610		target_stat_scsi_att_intr_port_##_name =		\
1611	__CONFIGFS_EATTR_RO(_name,					\
1612	target_stat_scsi_att_intr_port_show_attr_##_name);
1613
1614static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1615	struct se_ml_stat_grps *lgrps, char *page)
1616{
1617	struct se_lun_acl *lacl = container_of(lgrps,
1618			struct se_lun_acl, ml_stat_grps);
1619	struct se_node_acl *nacl = lacl->se_lun_nacl;
1620	struct se_dev_entry *deve;
1621	struct se_portal_group *tpg;
1622	ssize_t ret;
1623
1624	spin_lock_irq(&nacl->device_list_lock);
1625	deve = &nacl->device_list[lacl->mapped_lun];
1626	if (!deve->se_lun || !deve->se_lun_acl) {
1627		spin_unlock_irq(&nacl->device_list_lock);
1628		return -ENODEV;
1629	}
1630	tpg = nacl->se_tpg;
1631	/* scsiInstIndex */
1632	ret = snprintf(page, PAGE_SIZE, "%u\n",
1633			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1634	spin_unlock_irq(&nacl->device_list_lock);
1635	return ret;
1636}
1637DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1638
1639static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1640	struct se_ml_stat_grps *lgrps, char *page)
1641{
1642	struct se_lun_acl *lacl = container_of(lgrps,
1643			struct se_lun_acl, ml_stat_grps);
1644	struct se_node_acl *nacl = lacl->se_lun_nacl;
1645	struct se_dev_entry *deve;
1646	struct se_lun *lun;
1647	struct se_portal_group *tpg;
1648	ssize_t ret;
1649
1650	spin_lock_irq(&nacl->device_list_lock);
1651	deve = &nacl->device_list[lacl->mapped_lun];
1652	if (!deve->se_lun || !deve->se_lun_acl) {
1653		spin_unlock_irq(&nacl->device_list_lock);
1654		return -ENODEV;
1655	}
1656	tpg = nacl->se_tpg;
1657	lun = deve->se_lun;
1658	/* scsiDeviceIndex */
1659	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1660	spin_unlock_irq(&nacl->device_list_lock);
1661	return ret;
1662}
1663DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1664
1665static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1666	struct se_ml_stat_grps *lgrps, char *page)
1667{
1668	struct se_lun_acl *lacl = container_of(lgrps,
1669			struct se_lun_acl, ml_stat_grps);
1670	struct se_node_acl *nacl = lacl->se_lun_nacl;
1671	struct se_dev_entry *deve;
1672	struct se_portal_group *tpg;
1673	ssize_t ret;
1674
1675	spin_lock_irq(&nacl->device_list_lock);
1676	deve = &nacl->device_list[lacl->mapped_lun];
1677	if (!deve->se_lun || !deve->se_lun_acl) {
1678		spin_unlock_irq(&nacl->device_list_lock);
1679		return -ENODEV;
1680	}
1681	tpg = nacl->se_tpg;
1682	/* scsiPortIndex */
1683	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1684	spin_unlock_irq(&nacl->device_list_lock);
1685	return ret;
1686}
1687DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1688
1689static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1690	struct se_ml_stat_grps *lgrps, char *page)
1691{
1692	struct se_lun_acl *lacl = container_of(lgrps,
1693			struct se_lun_acl, ml_stat_grps);
1694	struct se_node_acl *nacl = lacl->se_lun_nacl;
1695	struct se_session *se_sess;
1696	struct se_portal_group *tpg;
1697	ssize_t ret;
1698
1699	spin_lock_irq(&nacl->nacl_sess_lock);
1700	se_sess = nacl->nacl_sess;
1701	if (!se_sess) {
1702		spin_unlock_irq(&nacl->nacl_sess_lock);
1703		return -ENODEV;
1704	}
1705
1706	tpg = nacl->se_tpg;
1707	/* scsiAttIntrPortIndex */
1708	ret = snprintf(page, PAGE_SIZE, "%u\n",
1709			tpg->se_tpg_tfo->sess_get_index(se_sess));
1710	spin_unlock_irq(&nacl->nacl_sess_lock);
1711	return ret;
1712}
1713DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1714
1715static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1716	struct se_ml_stat_grps *lgrps, char *page)
1717{
1718	struct se_lun_acl *lacl = container_of(lgrps,
1719			struct se_lun_acl, ml_stat_grps);
1720	struct se_node_acl *nacl = lacl->se_lun_nacl;
1721	struct se_dev_entry *deve;
1722	ssize_t ret;
1723
1724	spin_lock_irq(&nacl->device_list_lock);
1725	deve = &nacl->device_list[lacl->mapped_lun];
1726	if (!deve->se_lun || !deve->se_lun_acl) {
1727		spin_unlock_irq(&nacl->device_list_lock);
1728		return -ENODEV;
1729	}
1730	/* scsiAttIntrPortAuthIntrIdx */
1731	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1732	spin_unlock_irq(&nacl->device_list_lock);
1733	return ret;
1734}
1735DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1736
1737static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1738	struct se_ml_stat_grps *lgrps, char *page)
1739{
1740	struct se_lun_acl *lacl = container_of(lgrps,
1741			struct se_lun_acl, ml_stat_grps);
1742	struct se_node_acl *nacl = lacl->se_lun_nacl;
1743	struct se_session *se_sess;
1744	struct se_portal_group *tpg;
1745	ssize_t ret;
1746	unsigned char buf[64];
1747
1748	spin_lock_irq(&nacl->nacl_sess_lock);
1749	se_sess = nacl->nacl_sess;
1750	if (!se_sess) {
1751		spin_unlock_irq(&nacl->nacl_sess_lock);
1752		return -ENODEV;
1753	}
1754
1755	tpg = nacl->se_tpg;
1756	/* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1757	memset(buf, 0, 64);
1758	if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1759		tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess,
1760				(unsigned char *)&buf[0], 64);
1761
1762	ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1763	spin_unlock_irq(&nacl->nacl_sess_lock);
1764	return ret;
1765}
1766DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1767
1768CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1769		scsi_att_intr_port_group);
1770
1771static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1772	&target_stat_scsi_att_intr_port_inst.attr,
1773	&target_stat_scsi_att_intr_port_dev.attr,
1774	&target_stat_scsi_att_intr_port_port.attr,
1775	&target_stat_scsi_att_intr_port_indx.attr,
1776	&target_stat_scsi_att_intr_port_port_auth_indx.attr,
1777	&target_stat_scsi_att_intr_port_port_ident.attr,
1778	NULL,
1779};
1780
1781static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1782	.show_attribute		= target_stat_scsi_att_intr_port_attr_show,
1783	.store_attribute	= target_stat_scsi_att_intr_port_attr_store,
1784};
1785
1786static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1787	.ct_item_ops		= &target_stat_scsi_att_intr_port_attrib_ops,
1788	.ct_attrs		= target_stat_scsi_ath_intr_port_attrs,
1789	.ct_owner		= THIS_MODULE,
1790};
1791
1792/*
1793 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1794 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1795 */
1796void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1797{
1798	struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1799
1800	config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1801			"scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1802	config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1803			"scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1804
1805	ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1806	ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1807	ml_stat_grp->default_groups[2] = NULL;
1808}
v3.15
   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#include <scsi/scsi.h>
  37#include <scsi/scsi_device.h>
  38#include <scsi/scsi_host.h>
  39
  40#include <target/target_core_base.h>
  41#include <target/target_core_backend.h>
  42#include <target/target_core_fabric.h>
  43#include <target/target_core_configfs.h>
  44#include <target/configfs_macros.h>
  45
  46#include "target_core_internal.h"
  47
  48#ifndef INITIAL_JIFFIES
  49#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  50#endif
  51
  52#define NONE		"None"
  53#define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
  54
  55#define SCSI_LU_INDEX			1
  56#define LU_COUNT			1
  57
  58/*
  59 * SCSI Device Table
  60 */
  61
  62CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
  63#define DEV_STAT_SCSI_DEV_ATTR(_name, _mode)				\
  64static struct target_stat_scsi_dev_attribute				\
  65			target_stat_scsi_dev_##_name =			\
  66	__CONFIGFS_EATTR(_name, _mode,					\
  67	target_stat_scsi_dev_show_attr_##_name,				\
  68	target_stat_scsi_dev_store_attr_##_name);
  69
  70#define DEV_STAT_SCSI_DEV_ATTR_RO(_name)				\
  71static struct target_stat_scsi_dev_attribute				\
  72			target_stat_scsi_dev_##_name =			\
  73	__CONFIGFS_EATTR_RO(_name,					\
  74	target_stat_scsi_dev_show_attr_##_name);
  75
  76static ssize_t target_stat_scsi_dev_show_attr_inst(
  77	struct se_dev_stat_grps *sgrps, char *page)
  78{
  79	struct se_device *dev =
  80		container_of(sgrps, struct se_device, dev_stat_grps);
  81	struct se_hba *hba = dev->se_hba;
 
 
 
 
  82
  83	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
  84}
  85DEV_STAT_SCSI_DEV_ATTR_RO(inst);
  86
  87static ssize_t target_stat_scsi_dev_show_attr_indx(
  88	struct se_dev_stat_grps *sgrps, char *page)
  89{
  90	struct se_device *dev =
  91		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
  92
  93	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
  94}
  95DEV_STAT_SCSI_DEV_ATTR_RO(indx);
  96
  97static ssize_t target_stat_scsi_dev_show_attr_role(
  98	struct se_dev_stat_grps *sgrps, char *page)
  99{
 
 
 
 
 
 
 
 100	return snprintf(page, PAGE_SIZE, "Target\n");
 101}
 102DEV_STAT_SCSI_DEV_ATTR_RO(role);
 103
 104static ssize_t target_stat_scsi_dev_show_attr_ports(
 105	struct se_dev_stat_grps *sgrps, char *page)
 106{
 107	struct se_device *dev =
 108		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 109
 110	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
 111}
 112DEV_STAT_SCSI_DEV_ATTR_RO(ports);
 113
 114CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
 115
 116static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
 117	&target_stat_scsi_dev_inst.attr,
 118	&target_stat_scsi_dev_indx.attr,
 119	&target_stat_scsi_dev_role.attr,
 120	&target_stat_scsi_dev_ports.attr,
 121	NULL,
 122};
 123
 124static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
 125	.show_attribute		= target_stat_scsi_dev_attr_show,
 126	.store_attribute	= target_stat_scsi_dev_attr_store,
 127};
 128
 129static struct config_item_type target_stat_scsi_dev_cit = {
 130	.ct_item_ops		= &target_stat_scsi_dev_attrib_ops,
 131	.ct_attrs		= target_stat_scsi_dev_attrs,
 132	.ct_owner		= THIS_MODULE,
 133};
 134
 135/*
 136 * SCSI Target Device Table
 137 */
 138
 139CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
 140#define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode)			\
 141static struct target_stat_scsi_tgt_dev_attribute			\
 142			target_stat_scsi_tgt_dev_##_name =		\
 143	__CONFIGFS_EATTR(_name, _mode,					\
 144	target_stat_scsi_tgt_dev_show_attr_##_name,			\
 145	target_stat_scsi_tgt_dev_store_attr_##_name);
 146
 147#define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name)				\
 148static struct target_stat_scsi_tgt_dev_attribute			\
 149			target_stat_scsi_tgt_dev_##_name =		\
 150	__CONFIGFS_EATTR_RO(_name,					\
 151	target_stat_scsi_tgt_dev_show_attr_##_name);
 152
 153static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
 154	struct se_dev_stat_grps *sgrps, char *page)
 155{
 156	struct se_device *dev =
 157		container_of(sgrps, struct se_device, dev_stat_grps);
 158	struct se_hba *hba = dev->se_hba;
 
 
 
 
 159
 160	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 161}
 162DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
 163
 164static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
 165	struct se_dev_stat_grps *sgrps, char *page)
 166{
 167	struct se_device *dev =
 168		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 169
 170	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 171}
 172DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
 173
 174static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
 175	struct se_dev_stat_grps *sgrps, char *page)
 176{
 
 
 
 
 
 
 
 177	return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
 178}
 179DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
 180
 181static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
 182	struct se_dev_stat_grps *sgrps, char *page)
 183{
 184	struct se_device *dev =
 185		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 
 186
 187	if (dev->export_count)
 188		return snprintf(page, PAGE_SIZE, "activated");
 189	else
 190		return snprintf(page, PAGE_SIZE, "deactivated");
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 191}
 192DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
 193
 194static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
 195	struct se_dev_stat_grps *sgrps, char *page)
 196{
 197	struct se_device *dev =
 198		container_of(sgrps, struct se_device, dev_stat_grps);
 
 199	int non_accessible_lus;
 200
 201	if (dev->export_count)
 
 
 
 
 202		non_accessible_lus = 0;
 203	else
 
 
 
 
 
 204		non_accessible_lus = 1;
 
 
 205
 206	return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
 207}
 208DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
 209
 210static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
 211	struct se_dev_stat_grps *sgrps, char *page)
 212{
 213	struct se_device *dev =
 214		container_of(sgrps, struct se_device, dev_stat_grps);
 
 215
 216	return snprintf(page, PAGE_SIZE, "%lu\n",
 217			atomic_long_read(&dev->num_resets));
 
 
 218}
 219DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
 220
 221
 222CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
 223
 224static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
 225	&target_stat_scsi_tgt_dev_inst.attr,
 226	&target_stat_scsi_tgt_dev_indx.attr,
 227	&target_stat_scsi_tgt_dev_num_lus.attr,
 228	&target_stat_scsi_tgt_dev_status.attr,
 229	&target_stat_scsi_tgt_dev_non_access_lus.attr,
 230	&target_stat_scsi_tgt_dev_resets.attr,
 231	NULL,
 232};
 233
 234static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
 235	.show_attribute		= target_stat_scsi_tgt_dev_attr_show,
 236	.store_attribute	= target_stat_scsi_tgt_dev_attr_store,
 237};
 238
 239static struct config_item_type target_stat_scsi_tgt_dev_cit = {
 240	.ct_item_ops		= &target_stat_scsi_tgt_dev_attrib_ops,
 241	.ct_attrs		= target_stat_scsi_tgt_dev_attrs,
 242	.ct_owner		= THIS_MODULE,
 243};
 244
 245/*
 246 * SCSI Logical Unit Table
 247 */
 248
 249CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
 250#define DEV_STAT_SCSI_LU_ATTR(_name, _mode)				\
 251static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 252	__CONFIGFS_EATTR(_name, _mode,					\
 253	target_stat_scsi_lu_show_attr_##_name,				\
 254	target_stat_scsi_lu_store_attr_##_name);
 255
 256#define DEV_STAT_SCSI_LU_ATTR_RO(_name)					\
 257static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 258	__CONFIGFS_EATTR_RO(_name,					\
 259	target_stat_scsi_lu_show_attr_##_name);
 260
 261static ssize_t target_stat_scsi_lu_show_attr_inst(
 262	struct se_dev_stat_grps *sgrps, char *page)
 263{
 264	struct se_device *dev =
 265		container_of(sgrps, struct se_device, dev_stat_grps);
 266	struct se_hba *hba = dev->se_hba;
 
 
 
 
 267
 268	return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 269}
 270DEV_STAT_SCSI_LU_ATTR_RO(inst);
 271
 272static ssize_t target_stat_scsi_lu_show_attr_dev(
 273	struct se_dev_stat_grps *sgrps, char *page)
 274{
 275	struct se_device *dev =
 276		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 277
 278	return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 279}
 280DEV_STAT_SCSI_LU_ATTR_RO(dev);
 281
 282static ssize_t target_stat_scsi_lu_show_attr_indx(
 283	struct se_dev_stat_grps *sgrps, char *page)
 284{
 
 
 
 
 
 
 
 285	return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
 286}
 287DEV_STAT_SCSI_LU_ATTR_RO(indx);
 288
 289static ssize_t target_stat_scsi_lu_show_attr_lun(
 290	struct se_dev_stat_grps *sgrps, char *page)
 291{
 
 
 
 
 
 
 292	/* FIXME: scsiLuDefaultLun */
 293	return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
 294}
 295DEV_STAT_SCSI_LU_ATTR_RO(lun);
 296
 297static ssize_t target_stat_scsi_lu_show_attr_lu_name(
 298	struct se_dev_stat_grps *sgrps, char *page)
 299{
 300	struct se_device *dev =
 301		container_of(sgrps, struct se_device, dev_stat_grps);
 
 302
 
 
 303	/* scsiLuWwnName */
 304	return snprintf(page, PAGE_SIZE, "%s\n",
 305			(strlen(dev->t10_wwn.unit_serial)) ?
 306			dev->t10_wwn.unit_serial : "None");
 307}
 308DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
 309
 310static ssize_t target_stat_scsi_lu_show_attr_vend(
 311	struct se_dev_stat_grps *sgrps, char *page)
 312{
 313	struct se_device *dev =
 314		container_of(sgrps, struct se_device, dev_stat_grps);
 
 315	int i;
 316	char str[sizeof(dev->t10_wwn.vendor)+1];
 
 
 
 317
 318	/* scsiLuVendorId */
 319	for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
 320		str[i] = ISPRINT(dev->t10_wwn.vendor[i]) ?
 321			dev->t10_wwn.vendor[i] : ' ';
 322	str[i] = '\0';
 323	return snprintf(page, PAGE_SIZE, "%s\n", str);
 324}
 325DEV_STAT_SCSI_LU_ATTR_RO(vend);
 326
 327static ssize_t target_stat_scsi_lu_show_attr_prod(
 328	struct se_dev_stat_grps *sgrps, char *page)
 329{
 330	struct se_device *dev =
 331		container_of(sgrps, struct se_device, dev_stat_grps);
 
 332	int i;
 333	char str[sizeof(dev->t10_wwn.model)+1];
 
 
 
 334
 335	/* scsiLuProductId */
 336	for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
 337		str[i] = ISPRINT(dev->t10_wwn.model[i]) ?
 338			dev->t10_wwn.model[i] : ' ';
 339	str[i] = '\0';
 340	return snprintf(page, PAGE_SIZE, "%s\n", str);
 341}
 342DEV_STAT_SCSI_LU_ATTR_RO(prod);
 343
 344static ssize_t target_stat_scsi_lu_show_attr_rev(
 345	struct se_dev_stat_grps *sgrps, char *page)
 346{
 347	struct se_device *dev =
 348		container_of(sgrps, struct se_device, dev_stat_grps);
 
 349	int i;
 350	char str[sizeof(dev->t10_wwn.revision)+1];
 
 
 
 351
 352	/* scsiLuRevisionId */
 353	for (i = 0; i < sizeof(dev->t10_wwn.revision); i++)
 354		str[i] = ISPRINT(dev->t10_wwn.revision[i]) ?
 355			dev->t10_wwn.revision[i] : ' ';
 356	str[i] = '\0';
 357	return snprintf(page, PAGE_SIZE, "%s\n", str);
 358}
 359DEV_STAT_SCSI_LU_ATTR_RO(rev);
 360
 361static ssize_t target_stat_scsi_lu_show_attr_dev_type(
 362	struct se_dev_stat_grps *sgrps, char *page)
 363{
 364	struct se_device *dev =
 365		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 366
 367	/* scsiLuPeripheralType */
 368	return snprintf(page, PAGE_SIZE, "%u\n",
 369			dev->transport->get_device_type(dev));
 370}
 371DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
 372
 373static ssize_t target_stat_scsi_lu_show_attr_status(
 374	struct se_dev_stat_grps *sgrps, char *page)
 375{
 376	struct se_device *dev =
 377		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 378
 379	/* scsiLuStatus */
 380	return snprintf(page, PAGE_SIZE, "%s\n",
 381		(dev->export_count) ? "available" : "notavailable");
 
 382}
 383DEV_STAT_SCSI_LU_ATTR_RO(status);
 384
 385static ssize_t target_stat_scsi_lu_show_attr_state_bit(
 386	struct se_dev_stat_grps *sgrps, char *page)
 387{
 
 
 
 
 
 
 
 388	/* scsiLuState */
 389	return snprintf(page, PAGE_SIZE, "exposed\n");
 390}
 391DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
 392
 393static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
 394	struct se_dev_stat_grps *sgrps, char *page)
 395{
 396	struct se_device *dev =
 397		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 398
 399	/* scsiLuNumCommands */
 400	return snprintf(page, PAGE_SIZE, "%lu\n",
 401			atomic_long_read(&dev->num_cmds));
 402}
 403DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
 404
 405static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
 406	struct se_dev_stat_grps *sgrps, char *page)
 407{
 408	struct se_device *dev =
 409		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 410
 411	/* scsiLuReadMegaBytes */
 412	return snprintf(page, PAGE_SIZE, "%lu\n",
 413			atomic_long_read(&dev->read_bytes) >> 20);
 414}
 415DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
 416
 417static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
 418	struct se_dev_stat_grps *sgrps, char *page)
 419{
 420	struct se_device *dev =
 421		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 422
 423	/* scsiLuWrittenMegaBytes */
 424	return snprintf(page, PAGE_SIZE, "%lu\n",
 425			atomic_long_read(&dev->write_bytes) >> 20);
 426}
 427DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
 428
 429static ssize_t target_stat_scsi_lu_show_attr_resets(
 430	struct se_dev_stat_grps *sgrps, char *page)
 431{
 432	struct se_device *dev =
 433		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 434
 435	/* scsiLuInResets */
 436	return snprintf(page, PAGE_SIZE, "%lu\n", atomic_long_read(&dev->num_resets));
 437}
 438DEV_STAT_SCSI_LU_ATTR_RO(resets);
 439
 440static ssize_t target_stat_scsi_lu_show_attr_full_stat(
 441	struct se_dev_stat_grps *sgrps, char *page)
 442{
 
 
 
 
 
 
 
 443	/* FIXME: scsiLuOutTaskSetFullStatus */
 444	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 445}
 446DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
 447
 448static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
 449	struct se_dev_stat_grps *sgrps, char *page)
 450{
 
 
 
 
 
 
 
 451	/* FIXME: scsiLuHSInCommands */
 452	return snprintf(page, PAGE_SIZE, "%u\n", 0);
 453}
 454DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
 455
 456static ssize_t target_stat_scsi_lu_show_attr_creation_time(
 457	struct se_dev_stat_grps *sgrps, char *page)
 458{
 459	struct se_device *dev =
 460		container_of(sgrps, struct se_device, dev_stat_grps);
 
 
 
 
 461
 462	/* scsiLuCreationTime */
 463	return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
 464				INITIAL_JIFFIES) * 100 / HZ));
 465}
 466DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
 467
 468CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
 469
 470static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
 471	&target_stat_scsi_lu_inst.attr,
 472	&target_stat_scsi_lu_dev.attr,
 473	&target_stat_scsi_lu_indx.attr,
 474	&target_stat_scsi_lu_lun.attr,
 475	&target_stat_scsi_lu_lu_name.attr,
 476	&target_stat_scsi_lu_vend.attr,
 477	&target_stat_scsi_lu_prod.attr,
 478	&target_stat_scsi_lu_rev.attr,
 479	&target_stat_scsi_lu_dev_type.attr,
 480	&target_stat_scsi_lu_status.attr,
 481	&target_stat_scsi_lu_state_bit.attr,
 482	&target_stat_scsi_lu_num_cmds.attr,
 483	&target_stat_scsi_lu_read_mbytes.attr,
 484	&target_stat_scsi_lu_write_mbytes.attr,
 485	&target_stat_scsi_lu_resets.attr,
 486	&target_stat_scsi_lu_full_stat.attr,
 487	&target_stat_scsi_lu_hs_num_cmds.attr,
 488	&target_stat_scsi_lu_creation_time.attr,
 489	NULL,
 490};
 491
 492static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
 493	.show_attribute		= target_stat_scsi_lu_attr_show,
 494	.store_attribute	= target_stat_scsi_lu_attr_store,
 495};
 496
 497static struct config_item_type target_stat_scsi_lu_cit = {
 498	.ct_item_ops		= &target_stat_scsi_lu_attrib_ops,
 499	.ct_attrs		= target_stat_scsi_lu_attrs,
 500	.ct_owner		= THIS_MODULE,
 501};
 502
 503/*
 504 * Called from target_core_configfs.c:target_core_make_subdev() to setup
 505 * the target statistics groups + configfs CITs located in target_core_stat.c
 506 */
 507void target_stat_setup_dev_default_groups(struct se_device *dev)
 508{
 509	struct config_group *dev_stat_grp = &dev->dev_stat_grps.stat_group;
 510
 511	config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
 512			"scsi_dev", &target_stat_scsi_dev_cit);
 513	config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
 514			"scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 515	config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
 516			"scsi_lu", &target_stat_scsi_lu_cit);
 517
 518	dev_stat_grp->default_groups[0] = &dev->dev_stat_grps.scsi_dev_group;
 519	dev_stat_grp->default_groups[1] = &dev->dev_stat_grps.scsi_tgt_dev_group;
 520	dev_stat_grp->default_groups[2] = &dev->dev_stat_grps.scsi_lu_group;
 521	dev_stat_grp->default_groups[3] = NULL;
 522}
 523
 524/*
 525 * SCSI Port Table
 526 */
 527
 528CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
 529#define DEV_STAT_SCSI_PORT_ATTR(_name, _mode)				\
 530static struct target_stat_scsi_port_attribute				\
 531			target_stat_scsi_port_##_name =			\
 532	__CONFIGFS_EATTR(_name, _mode,					\
 533	target_stat_scsi_port_show_attr_##_name,			\
 534	target_stat_scsi_port_store_attr_##_name);
 535
 536#define DEV_STAT_SCSI_PORT_ATTR_RO(_name)				\
 537static struct target_stat_scsi_port_attribute				\
 538			target_stat_scsi_port_##_name =			\
 539	__CONFIGFS_EATTR_RO(_name,					\
 540	target_stat_scsi_port_show_attr_##_name);
 541
 542static ssize_t target_stat_scsi_port_show_attr_inst(
 543	struct se_port_stat_grps *pgrps, char *page)
 544{
 545	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 546	struct se_port *sep;
 547	struct se_device *dev = lun->lun_se_dev;
 548	struct se_hba *hba;
 549	ssize_t ret;
 550
 551	spin_lock(&lun->lun_sep_lock);
 552	sep = lun->lun_sep;
 553	if (!sep) {
 554		spin_unlock(&lun->lun_sep_lock);
 555		return -ENODEV;
 556	}
 557	hba = dev->se_hba;
 558	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 559	spin_unlock(&lun->lun_sep_lock);
 560	return ret;
 561}
 562DEV_STAT_SCSI_PORT_ATTR_RO(inst);
 563
 564static ssize_t target_stat_scsi_port_show_attr_dev(
 565	struct se_port_stat_grps *pgrps, char *page)
 566{
 567	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 568	struct se_port *sep;
 569	struct se_device *dev = lun->lun_se_dev;
 570	ssize_t ret;
 571
 572	spin_lock(&lun->lun_sep_lock);
 573	sep = lun->lun_sep;
 574	if (!sep) {
 575		spin_unlock(&lun->lun_sep_lock);
 576		return -ENODEV;
 577	}
 578	ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 579	spin_unlock(&lun->lun_sep_lock);
 580	return ret;
 581}
 582DEV_STAT_SCSI_PORT_ATTR_RO(dev);
 583
 584static ssize_t target_stat_scsi_port_show_attr_indx(
 585	struct se_port_stat_grps *pgrps, char *page)
 586{
 587	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 588	struct se_port *sep;
 589	ssize_t ret;
 590
 591	spin_lock(&lun->lun_sep_lock);
 592	sep = lun->lun_sep;
 593	if (!sep) {
 594		spin_unlock(&lun->lun_sep_lock);
 595		return -ENODEV;
 596	}
 597	ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 598	spin_unlock(&lun->lun_sep_lock);
 599	return ret;
 600}
 601DEV_STAT_SCSI_PORT_ATTR_RO(indx);
 602
 603static ssize_t target_stat_scsi_port_show_attr_role(
 604	struct se_port_stat_grps *pgrps, char *page)
 605{
 606	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 607	struct se_device *dev = lun->lun_se_dev;
 608	struct se_port *sep;
 609	ssize_t ret;
 610
 611	if (!dev)
 612		return -ENODEV;
 613
 614	spin_lock(&lun->lun_sep_lock);
 615	sep = lun->lun_sep;
 616	if (!sep) {
 617		spin_unlock(&lun->lun_sep_lock);
 618		return -ENODEV;
 619	}
 620	ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 621	spin_unlock(&lun->lun_sep_lock);
 622	return ret;
 623}
 624DEV_STAT_SCSI_PORT_ATTR_RO(role);
 625
 626static ssize_t target_stat_scsi_port_show_attr_busy_count(
 627	struct se_port_stat_grps *pgrps, char *page)
 628{
 629	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 630	struct se_port *sep;
 631	ssize_t ret;
 632
 633	spin_lock(&lun->lun_sep_lock);
 634	sep = lun->lun_sep;
 635	if (!sep) {
 636		spin_unlock(&lun->lun_sep_lock);
 637		return -ENODEV;
 638	}
 639	/* FIXME: scsiPortBusyStatuses  */
 640	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 641	spin_unlock(&lun->lun_sep_lock);
 642	return ret;
 643}
 644DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
 645
 646CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
 647
 648static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 649	&target_stat_scsi_port_inst.attr,
 650	&target_stat_scsi_port_dev.attr,
 651	&target_stat_scsi_port_indx.attr,
 652	&target_stat_scsi_port_role.attr,
 653	&target_stat_scsi_port_busy_count.attr,
 654	NULL,
 655};
 656
 657static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
 658	.show_attribute		= target_stat_scsi_port_attr_show,
 659	.store_attribute	= target_stat_scsi_port_attr_store,
 660};
 661
 662static struct config_item_type target_stat_scsi_port_cit = {
 663	.ct_item_ops		= &target_stat_scsi_port_attrib_ops,
 664	.ct_attrs		= target_stat_scsi_port_attrs,
 665	.ct_owner		= THIS_MODULE,
 666};
 667
 668/*
 669 * SCSI Target Port Table
 670 */
 671CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
 672#define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode)			\
 673static struct target_stat_scsi_tgt_port_attribute			\
 674			target_stat_scsi_tgt_port_##_name =		\
 675	__CONFIGFS_EATTR(_name, _mode,					\
 676	target_stat_scsi_tgt_port_show_attr_##_name,			\
 677	target_stat_scsi_tgt_port_store_attr_##_name);
 678
 679#define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name)				\
 680static struct target_stat_scsi_tgt_port_attribute			\
 681			target_stat_scsi_tgt_port_##_name =		\
 682	__CONFIGFS_EATTR_RO(_name,					\
 683	target_stat_scsi_tgt_port_show_attr_##_name);
 684
 685static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
 686	struct se_port_stat_grps *pgrps, char *page)
 687{
 688	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 689	struct se_device *dev = lun->lun_se_dev;
 690	struct se_port *sep;
 691	struct se_hba *hba;
 692	ssize_t ret;
 693
 694	spin_lock(&lun->lun_sep_lock);
 695	sep = lun->lun_sep;
 696	if (!sep) {
 697		spin_unlock(&lun->lun_sep_lock);
 698		return -ENODEV;
 699	}
 700	hba = dev->se_hba;
 701	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 702	spin_unlock(&lun->lun_sep_lock);
 703	return ret;
 704}
 705DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
 706
 707static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
 708	struct se_port_stat_grps *pgrps, char *page)
 709{
 710	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 711	struct se_device *dev = lun->lun_se_dev;
 712	struct se_port *sep;
 713	ssize_t ret;
 714
 715	spin_lock(&lun->lun_sep_lock);
 716	sep = lun->lun_sep;
 717	if (!sep) {
 718		spin_unlock(&lun->lun_sep_lock);
 719		return -ENODEV;
 720	}
 721	ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 722	spin_unlock(&lun->lun_sep_lock);
 723	return ret;
 724}
 725DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
 726
 727static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
 728	struct se_port_stat_grps *pgrps, char *page)
 729{
 730	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 731	struct se_port *sep;
 732	ssize_t ret;
 733
 734	spin_lock(&lun->lun_sep_lock);
 735	sep = lun->lun_sep;
 736	if (!sep) {
 737		spin_unlock(&lun->lun_sep_lock);
 738		return -ENODEV;
 739	}
 740	ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 741	spin_unlock(&lun->lun_sep_lock);
 742	return ret;
 743}
 744DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
 745
 746static ssize_t target_stat_scsi_tgt_port_show_attr_name(
 747	struct se_port_stat_grps *pgrps, char *page)
 748{
 749	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 750	struct se_port *sep;
 751	struct se_portal_group *tpg;
 752	ssize_t ret;
 753
 754	spin_lock(&lun->lun_sep_lock);
 755	sep = lun->lun_sep;
 756	if (!sep) {
 757		spin_unlock(&lun->lun_sep_lock);
 758		return -ENODEV;
 759	}
 760	tpg = sep->sep_tpg;
 761
 762	ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 763		tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
 764	spin_unlock(&lun->lun_sep_lock);
 765	return ret;
 766}
 767DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
 768
 769static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
 770	struct se_port_stat_grps *pgrps, char *page)
 771{
 772	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 773	struct se_port *sep;
 774	struct se_portal_group *tpg;
 775	ssize_t ret;
 776
 777	spin_lock(&lun->lun_sep_lock);
 778	sep = lun->lun_sep;
 779	if (!sep) {
 780		spin_unlock(&lun->lun_sep_lock);
 781		return -ENODEV;
 782	}
 783	tpg = sep->sep_tpg;
 784
 785	ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 786		tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 787		tpg->se_tpg_tfo->tpg_get_tag(tpg));
 788	spin_unlock(&lun->lun_sep_lock);
 789	return ret;
 790}
 791DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
 792
 793static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
 794	struct se_port_stat_grps *pgrps, char *page)
 795{
 796	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 797	struct se_port *sep;
 
 798	ssize_t ret;
 799
 800	spin_lock(&lun->lun_sep_lock);
 801	sep = lun->lun_sep;
 802	if (!sep) {
 803		spin_unlock(&lun->lun_sep_lock);
 804		return -ENODEV;
 805	}
 
 806
 807	ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
 808	spin_unlock(&lun->lun_sep_lock);
 809	return ret;
 810}
 811DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
 812
 813static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
 814	struct se_port_stat_grps *pgrps, char *page)
 815{
 816	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 817	struct se_port *sep;
 
 818	ssize_t ret;
 819
 820	spin_lock(&lun->lun_sep_lock);
 821	sep = lun->lun_sep;
 822	if (!sep) {
 823		spin_unlock(&lun->lun_sep_lock);
 824		return -ENODEV;
 825	}
 
 826
 827	ret = snprintf(page, PAGE_SIZE, "%u\n",
 828			(u32)(sep->sep_stats.rx_data_octets >> 20));
 829	spin_unlock(&lun->lun_sep_lock);
 830	return ret;
 831}
 832DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
 833
 834static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
 835	struct se_port_stat_grps *pgrps, char *page)
 836{
 837	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 838	struct se_port *sep;
 
 839	ssize_t ret;
 840
 841	spin_lock(&lun->lun_sep_lock);
 842	sep = lun->lun_sep;
 843	if (!sep) {
 844		spin_unlock(&lun->lun_sep_lock);
 845		return -ENODEV;
 846	}
 
 847
 848	ret = snprintf(page, PAGE_SIZE, "%u\n",
 849			(u32)(sep->sep_stats.tx_data_octets >> 20));
 850	spin_unlock(&lun->lun_sep_lock);
 851	return ret;
 852}
 853DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
 854
 855static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
 856	struct se_port_stat_grps *pgrps, char *page)
 857{
 858	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 859	struct se_port *sep;
 
 860	ssize_t ret;
 861
 862	spin_lock(&lun->lun_sep_lock);
 863	sep = lun->lun_sep;
 864	if (!sep) {
 865		spin_unlock(&lun->lun_sep_lock);
 866		return -ENODEV;
 867	}
 
 868
 869	/* FIXME: scsiTgtPortHsInCommands */
 870	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 871	spin_unlock(&lun->lun_sep_lock);
 872	return ret;
 873}
 874DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
 875
 876CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
 877		scsi_tgt_port_group);
 878
 879static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
 880	&target_stat_scsi_tgt_port_inst.attr,
 881	&target_stat_scsi_tgt_port_dev.attr,
 882	&target_stat_scsi_tgt_port_indx.attr,
 883	&target_stat_scsi_tgt_port_name.attr,
 884	&target_stat_scsi_tgt_port_port_index.attr,
 885	&target_stat_scsi_tgt_port_in_cmds.attr,
 886	&target_stat_scsi_tgt_port_write_mbytes.attr,
 887	&target_stat_scsi_tgt_port_read_mbytes.attr,
 888	&target_stat_scsi_tgt_port_hs_in_cmds.attr,
 889	NULL,
 890};
 891
 892static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
 893	.show_attribute		= target_stat_scsi_tgt_port_attr_show,
 894	.store_attribute	= target_stat_scsi_tgt_port_attr_store,
 895};
 896
 897static struct config_item_type target_stat_scsi_tgt_port_cit = {
 898	.ct_item_ops		= &target_stat_scsi_tgt_port_attrib_ops,
 899	.ct_attrs		= target_stat_scsi_tgt_port_attrs,
 900	.ct_owner		= THIS_MODULE,
 901};
 902
 903/*
 904 * SCSI Transport Table
 905o */
 906
 907CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
 908#define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode)			\
 909static struct target_stat_scsi_transport_attribute			\
 910			target_stat_scsi_transport_##_name =		\
 911	__CONFIGFS_EATTR(_name, _mode,					\
 912	target_stat_scsi_transport_show_attr_##_name,			\
 913	target_stat_scsi_transport_store_attr_##_name);
 914
 915#define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name)				\
 916static struct target_stat_scsi_transport_attribute			\
 917			target_stat_scsi_transport_##_name =		\
 918	__CONFIGFS_EATTR_RO(_name,					\
 919	target_stat_scsi_transport_show_attr_##_name);
 920
 921static ssize_t target_stat_scsi_transport_show_attr_inst(
 922	struct se_port_stat_grps *pgrps, char *page)
 923{
 924	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 925	struct se_device *dev = lun->lun_se_dev;
 926	struct se_port *sep;
 927	struct se_hba *hba;
 928	ssize_t ret;
 929
 930	spin_lock(&lun->lun_sep_lock);
 931	sep = lun->lun_sep;
 932	if (!sep) {
 933		spin_unlock(&lun->lun_sep_lock);
 934		return -ENODEV;
 935	}
 936
 937	hba = dev->se_hba;
 938	ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 939	spin_unlock(&lun->lun_sep_lock);
 940	return ret;
 941}
 942DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
 943
 944static ssize_t target_stat_scsi_transport_show_attr_device(
 945	struct se_port_stat_grps *pgrps, char *page)
 946{
 947	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 948	struct se_port *sep;
 949	struct se_portal_group *tpg;
 950	ssize_t ret;
 951
 952	spin_lock(&lun->lun_sep_lock);
 953	sep = lun->lun_sep;
 954	if (!sep) {
 955		spin_unlock(&lun->lun_sep_lock);
 956		return -ENODEV;
 957	}
 958	tpg = sep->sep_tpg;
 959	/* scsiTransportType */
 960	ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
 961			tpg->se_tpg_tfo->get_fabric_name());
 962	spin_unlock(&lun->lun_sep_lock);
 963	return ret;
 964}
 965DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
 966
 967static ssize_t target_stat_scsi_transport_show_attr_indx(
 968	struct se_port_stat_grps *pgrps, char *page)
 969{
 970	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 971	struct se_port *sep;
 972	struct se_portal_group *tpg;
 973	ssize_t ret;
 974
 975	spin_lock(&lun->lun_sep_lock);
 976	sep = lun->lun_sep;
 977	if (!sep) {
 978		spin_unlock(&lun->lun_sep_lock);
 979		return -ENODEV;
 980	}
 981	tpg = sep->sep_tpg;
 982	ret = snprintf(page, PAGE_SIZE, "%u\n",
 983			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
 984	spin_unlock(&lun->lun_sep_lock);
 985	return ret;
 986}
 987DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
 988
 989static ssize_t target_stat_scsi_transport_show_attr_dev_name(
 990	struct se_port_stat_grps *pgrps, char *page)
 991{
 992	struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 993	struct se_device *dev = lun->lun_se_dev;
 994	struct se_port *sep;
 995	struct se_portal_group *tpg;
 996	struct t10_wwn *wwn;
 997	ssize_t ret;
 998
 999	spin_lock(&lun->lun_sep_lock);
1000	sep = lun->lun_sep;
1001	if (!sep) {
1002		spin_unlock(&lun->lun_sep_lock);
1003		return -ENODEV;
1004	}
1005	tpg = sep->sep_tpg;
1006	wwn = &dev->t10_wwn;
1007	/* scsiTransportDevName */
1008	ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1009			tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1010			(strlen(wwn->unit_serial)) ? wwn->unit_serial :
1011			wwn->vendor);
1012	spin_unlock(&lun->lun_sep_lock);
1013	return ret;
1014}
1015DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1016
1017CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1018		scsi_transport_group);
1019
1020static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1021	&target_stat_scsi_transport_inst.attr,
1022	&target_stat_scsi_transport_device.attr,
1023	&target_stat_scsi_transport_indx.attr,
1024	&target_stat_scsi_transport_dev_name.attr,
1025	NULL,
1026};
1027
1028static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1029	.show_attribute		= target_stat_scsi_transport_attr_show,
1030	.store_attribute	= target_stat_scsi_transport_attr_store,
1031};
1032
1033static struct config_item_type target_stat_scsi_transport_cit = {
1034	.ct_item_ops		= &target_stat_scsi_transport_attrib_ops,
1035	.ct_attrs		= target_stat_scsi_transport_attrs,
1036	.ct_owner		= THIS_MODULE,
1037};
1038
1039/*
1040 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1041 * the target port statistics groups + configfs CITs located in target_core_stat.c
1042 */
1043void target_stat_setup_port_default_groups(struct se_lun *lun)
1044{
1045	struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1046
1047	config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1048			"scsi_port", &target_stat_scsi_port_cit);
1049	config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1050			"scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1051	config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1052			"scsi_transport", &target_stat_scsi_transport_cit);
1053
1054	port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1055	port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1056	port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1057	port_stat_grp->default_groups[3] = NULL;
1058}
1059
1060/*
1061 * SCSI Authorized Initiator Table
1062 */
1063
1064CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1065#define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode)			\
1066static struct target_stat_scsi_auth_intr_attribute			\
1067			target_stat_scsi_auth_intr_##_name =		\
1068	__CONFIGFS_EATTR(_name, _mode,					\
1069	target_stat_scsi_auth_intr_show_attr_##_name,			\
1070	target_stat_scsi_auth_intr_store_attr_##_name);
1071
1072#define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name)				\
1073static struct target_stat_scsi_auth_intr_attribute			\
1074			target_stat_scsi_auth_intr_##_name =		\
1075	__CONFIGFS_EATTR_RO(_name,					\
1076	target_stat_scsi_auth_intr_show_attr_##_name);
1077
1078static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1079	struct se_ml_stat_grps *lgrps, char *page)
1080{
1081	struct se_lun_acl *lacl = container_of(lgrps,
1082			struct se_lun_acl, ml_stat_grps);
1083	struct se_node_acl *nacl = lacl->se_lun_nacl;
1084	struct se_dev_entry *deve;
1085	struct se_portal_group *tpg;
1086	ssize_t ret;
1087
1088	spin_lock_irq(&nacl->device_list_lock);
1089	deve = nacl->device_list[lacl->mapped_lun];
1090	if (!deve->se_lun || !deve->se_lun_acl) {
1091		spin_unlock_irq(&nacl->device_list_lock);
1092		return -ENODEV;
1093	}
1094	tpg = nacl->se_tpg;
1095	/* scsiInstIndex */
1096	ret = snprintf(page, PAGE_SIZE, "%u\n",
1097			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1098	spin_unlock_irq(&nacl->device_list_lock);
1099	return ret;
1100}
1101DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1102
1103static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1104	struct se_ml_stat_grps *lgrps, char *page)
1105{
1106	struct se_lun_acl *lacl = container_of(lgrps,
1107			struct se_lun_acl, ml_stat_grps);
1108	struct se_node_acl *nacl = lacl->se_lun_nacl;
1109	struct se_dev_entry *deve;
1110	struct se_lun *lun;
 
1111	ssize_t ret;
1112
1113	spin_lock_irq(&nacl->device_list_lock);
1114	deve = nacl->device_list[lacl->mapped_lun];
1115	if (!deve->se_lun || !deve->se_lun_acl) {
1116		spin_unlock_irq(&nacl->device_list_lock);
1117		return -ENODEV;
1118	}
 
1119	lun = deve->se_lun;
1120	/* scsiDeviceIndex */
1121	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1122	spin_unlock_irq(&nacl->device_list_lock);
1123	return ret;
1124}
1125DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1126
1127static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1128	struct se_ml_stat_grps *lgrps, char *page)
1129{
1130	struct se_lun_acl *lacl = container_of(lgrps,
1131			struct se_lun_acl, ml_stat_grps);
1132	struct se_node_acl *nacl = lacl->se_lun_nacl;
1133	struct se_dev_entry *deve;
1134	struct se_portal_group *tpg;
1135	ssize_t ret;
1136
1137	spin_lock_irq(&nacl->device_list_lock);
1138	deve = nacl->device_list[lacl->mapped_lun];
1139	if (!deve->se_lun || !deve->se_lun_acl) {
1140		spin_unlock_irq(&nacl->device_list_lock);
1141		return -ENODEV;
1142	}
1143	tpg = nacl->se_tpg;
1144	/* scsiAuthIntrTgtPortIndex */
1145	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1146	spin_unlock_irq(&nacl->device_list_lock);
1147	return ret;
1148}
1149DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1150
1151static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1152	struct se_ml_stat_grps *lgrps, char *page)
1153{
1154	struct se_lun_acl *lacl = container_of(lgrps,
1155			struct se_lun_acl, ml_stat_grps);
1156	struct se_node_acl *nacl = lacl->se_lun_nacl;
1157	struct se_dev_entry *deve;
1158	ssize_t ret;
1159
1160	spin_lock_irq(&nacl->device_list_lock);
1161	deve = nacl->device_list[lacl->mapped_lun];
1162	if (!deve->se_lun || !deve->se_lun_acl) {
1163		spin_unlock_irq(&nacl->device_list_lock);
1164		return -ENODEV;
1165	}
1166	/* scsiAuthIntrIndex */
1167	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1168	spin_unlock_irq(&nacl->device_list_lock);
1169	return ret;
1170}
1171DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1172
1173static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1174	struct se_ml_stat_grps *lgrps, char *page)
1175{
1176	struct se_lun_acl *lacl = container_of(lgrps,
1177			struct se_lun_acl, ml_stat_grps);
1178	struct se_node_acl *nacl = lacl->se_lun_nacl;
1179	struct se_dev_entry *deve;
1180	ssize_t ret;
1181
1182	spin_lock_irq(&nacl->device_list_lock);
1183	deve = nacl->device_list[lacl->mapped_lun];
1184	if (!deve->se_lun || !deve->se_lun_acl) {
1185		spin_unlock_irq(&nacl->device_list_lock);
1186		return -ENODEV;
1187	}
1188	/* scsiAuthIntrDevOrPort */
1189	ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1190	spin_unlock_irq(&nacl->device_list_lock);
1191	return ret;
1192}
1193DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1194
1195static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1196	struct se_ml_stat_grps *lgrps, char *page)
1197{
1198	struct se_lun_acl *lacl = container_of(lgrps,
1199			struct se_lun_acl, ml_stat_grps);
1200	struct se_node_acl *nacl = lacl->se_lun_nacl;
1201	struct se_dev_entry *deve;
1202	ssize_t ret;
1203
1204	spin_lock_irq(&nacl->device_list_lock);
1205	deve = nacl->device_list[lacl->mapped_lun];
1206	if (!deve->se_lun || !deve->se_lun_acl) {
1207		spin_unlock_irq(&nacl->device_list_lock);
1208		return -ENODEV;
1209	}
1210	/* scsiAuthIntrName */
1211	ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1212	spin_unlock_irq(&nacl->device_list_lock);
1213	return ret;
1214}
1215DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1216
1217static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1218	struct se_ml_stat_grps *lgrps, char *page)
1219{
1220	struct se_lun_acl *lacl = container_of(lgrps,
1221			struct se_lun_acl, ml_stat_grps);
1222	struct se_node_acl *nacl = lacl->se_lun_nacl;
1223	struct se_dev_entry *deve;
1224	ssize_t ret;
1225
1226	spin_lock_irq(&nacl->device_list_lock);
1227	deve = nacl->device_list[lacl->mapped_lun];
1228	if (!deve->se_lun || !deve->se_lun_acl) {
1229		spin_unlock_irq(&nacl->device_list_lock);
1230		return -ENODEV;
1231	}
1232	/* FIXME: scsiAuthIntrLunMapIndex */
1233	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1234	spin_unlock_irq(&nacl->device_list_lock);
1235	return ret;
1236}
1237DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1238
1239static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1240	struct se_ml_stat_grps *lgrps, char *page)
1241{
1242	struct se_lun_acl *lacl = container_of(lgrps,
1243			struct se_lun_acl, ml_stat_grps);
1244	struct se_node_acl *nacl = lacl->se_lun_nacl;
1245	struct se_dev_entry *deve;
1246	ssize_t ret;
1247
1248	spin_lock_irq(&nacl->device_list_lock);
1249	deve = nacl->device_list[lacl->mapped_lun];
1250	if (!deve->se_lun || !deve->se_lun_acl) {
1251		spin_unlock_irq(&nacl->device_list_lock);
1252		return -ENODEV;
1253	}
1254	/* scsiAuthIntrAttachedTimes */
1255	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1256	spin_unlock_irq(&nacl->device_list_lock);
1257	return ret;
1258}
1259DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1260
1261static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1262	struct se_ml_stat_grps *lgrps, char *page)
1263{
1264	struct se_lun_acl *lacl = container_of(lgrps,
1265			struct se_lun_acl, ml_stat_grps);
1266	struct se_node_acl *nacl = lacl->se_lun_nacl;
1267	struct se_dev_entry *deve;
1268	ssize_t ret;
1269
1270	spin_lock_irq(&nacl->device_list_lock);
1271	deve = nacl->device_list[lacl->mapped_lun];
1272	if (!deve->se_lun || !deve->se_lun_acl) {
1273		spin_unlock_irq(&nacl->device_list_lock);
1274		return -ENODEV;
1275	}
1276	/* scsiAuthIntrOutCommands */
1277	ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1278	spin_unlock_irq(&nacl->device_list_lock);
1279	return ret;
1280}
1281DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1282
1283static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1284	struct se_ml_stat_grps *lgrps, char *page)
1285{
1286	struct se_lun_acl *lacl = container_of(lgrps,
1287			struct se_lun_acl, ml_stat_grps);
1288	struct se_node_acl *nacl = lacl->se_lun_nacl;
1289	struct se_dev_entry *deve;
1290	ssize_t ret;
1291
1292	spin_lock_irq(&nacl->device_list_lock);
1293	deve = nacl->device_list[lacl->mapped_lun];
1294	if (!deve->se_lun || !deve->se_lun_acl) {
1295		spin_unlock_irq(&nacl->device_list_lock);
1296		return -ENODEV;
1297	}
1298	/* scsiAuthIntrReadMegaBytes */
1299	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1300	spin_unlock_irq(&nacl->device_list_lock);
1301	return ret;
1302}
1303DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1304
1305static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1306	struct se_ml_stat_grps *lgrps, char *page)
1307{
1308	struct se_lun_acl *lacl = container_of(lgrps,
1309			struct se_lun_acl, ml_stat_grps);
1310	struct se_node_acl *nacl = lacl->se_lun_nacl;
1311	struct se_dev_entry *deve;
1312	ssize_t ret;
1313
1314	spin_lock_irq(&nacl->device_list_lock);
1315	deve = nacl->device_list[lacl->mapped_lun];
1316	if (!deve->se_lun || !deve->se_lun_acl) {
1317		spin_unlock_irq(&nacl->device_list_lock);
1318		return -ENODEV;
1319	}
1320	/* scsiAuthIntrWrittenMegaBytes */
1321	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1322	spin_unlock_irq(&nacl->device_list_lock);
1323	return ret;
1324}
1325DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1326
1327static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1328	struct se_ml_stat_grps *lgrps, char *page)
1329{
1330	struct se_lun_acl *lacl = container_of(lgrps,
1331			struct se_lun_acl, ml_stat_grps);
1332	struct se_node_acl *nacl = lacl->se_lun_nacl;
1333	struct se_dev_entry *deve;
1334	ssize_t ret;
1335
1336	spin_lock_irq(&nacl->device_list_lock);
1337	deve = nacl->device_list[lacl->mapped_lun];
1338	if (!deve->se_lun || !deve->se_lun_acl) {
1339		spin_unlock_irq(&nacl->device_list_lock);
1340		return -ENODEV;
1341	}
1342	/* FIXME: scsiAuthIntrHSOutCommands */
1343	ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1344	spin_unlock_irq(&nacl->device_list_lock);
1345	return ret;
1346}
1347DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1348
1349static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1350	struct se_ml_stat_grps *lgrps, char *page)
1351{
1352	struct se_lun_acl *lacl = container_of(lgrps,
1353			struct se_lun_acl, ml_stat_grps);
1354	struct se_node_acl *nacl = lacl->se_lun_nacl;
1355	struct se_dev_entry *deve;
1356	ssize_t ret;
1357
1358	spin_lock_irq(&nacl->device_list_lock);
1359	deve = nacl->device_list[lacl->mapped_lun];
1360	if (!deve->se_lun || !deve->se_lun_acl) {
1361		spin_unlock_irq(&nacl->device_list_lock);
1362		return -ENODEV;
1363	}
1364	/* scsiAuthIntrLastCreation */
1365	ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1366				INITIAL_JIFFIES) * 100 / HZ));
1367	spin_unlock_irq(&nacl->device_list_lock);
1368	return ret;
1369}
1370DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1371
1372static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1373	struct se_ml_stat_grps *lgrps, char *page)
1374{
1375	struct se_lun_acl *lacl = container_of(lgrps,
1376			struct se_lun_acl, ml_stat_grps);
1377	struct se_node_acl *nacl = lacl->se_lun_nacl;
1378	struct se_dev_entry *deve;
1379	ssize_t ret;
1380
1381	spin_lock_irq(&nacl->device_list_lock);
1382	deve = nacl->device_list[lacl->mapped_lun];
1383	if (!deve->se_lun || !deve->se_lun_acl) {
1384		spin_unlock_irq(&nacl->device_list_lock);
1385		return -ENODEV;
1386	}
1387	/* FIXME: scsiAuthIntrRowStatus */
1388	ret = snprintf(page, PAGE_SIZE, "Ready\n");
1389	spin_unlock_irq(&nacl->device_list_lock);
1390	return ret;
1391}
1392DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1393
1394CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1395		scsi_auth_intr_group);
1396
1397static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1398	&target_stat_scsi_auth_intr_inst.attr,
1399	&target_stat_scsi_auth_intr_dev.attr,
1400	&target_stat_scsi_auth_intr_port.attr,
1401	&target_stat_scsi_auth_intr_indx.attr,
1402	&target_stat_scsi_auth_intr_dev_or_port.attr,
1403	&target_stat_scsi_auth_intr_intr_name.attr,
1404	&target_stat_scsi_auth_intr_map_indx.attr,
1405	&target_stat_scsi_auth_intr_att_count.attr,
1406	&target_stat_scsi_auth_intr_num_cmds.attr,
1407	&target_stat_scsi_auth_intr_read_mbytes.attr,
1408	&target_stat_scsi_auth_intr_write_mbytes.attr,
1409	&target_stat_scsi_auth_intr_hs_num_cmds.attr,
1410	&target_stat_scsi_auth_intr_creation_time.attr,
1411	&target_stat_scsi_auth_intr_row_status.attr,
1412	NULL,
1413};
1414
1415static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1416	.show_attribute		= target_stat_scsi_auth_intr_attr_show,
1417	.store_attribute	= target_stat_scsi_auth_intr_attr_store,
1418};
1419
1420static struct config_item_type target_stat_scsi_auth_intr_cit = {
1421	.ct_item_ops		= &target_stat_scsi_auth_intr_attrib_ops,
1422	.ct_attrs		= target_stat_scsi_auth_intr_attrs,
1423	.ct_owner		= THIS_MODULE,
1424};
1425
1426/*
1427 * SCSI Attached Initiator Port Table
1428 */
1429
1430CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1431#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode)			\
1432static struct target_stat_scsi_att_intr_port_attribute			\
1433		target_stat_scsi_att_intr_port_##_name =		\
1434	__CONFIGFS_EATTR(_name, _mode,					\
1435	target_stat_scsi_att_intr_port_show_attr_##_name,		\
1436	target_stat_scsi_att_intr_port_store_attr_##_name);
1437
1438#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name)			\
1439static struct target_stat_scsi_att_intr_port_attribute			\
1440		target_stat_scsi_att_intr_port_##_name =		\
1441	__CONFIGFS_EATTR_RO(_name,					\
1442	target_stat_scsi_att_intr_port_show_attr_##_name);
1443
1444static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1445	struct se_ml_stat_grps *lgrps, char *page)
1446{
1447	struct se_lun_acl *lacl = container_of(lgrps,
1448			struct se_lun_acl, ml_stat_grps);
1449	struct se_node_acl *nacl = lacl->se_lun_nacl;
1450	struct se_dev_entry *deve;
1451	struct se_portal_group *tpg;
1452	ssize_t ret;
1453
1454	spin_lock_irq(&nacl->device_list_lock);
1455	deve = nacl->device_list[lacl->mapped_lun];
1456	if (!deve->se_lun || !deve->se_lun_acl) {
1457		spin_unlock_irq(&nacl->device_list_lock);
1458		return -ENODEV;
1459	}
1460	tpg = nacl->se_tpg;
1461	/* scsiInstIndex */
1462	ret = snprintf(page, PAGE_SIZE, "%u\n",
1463			tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1464	spin_unlock_irq(&nacl->device_list_lock);
1465	return ret;
1466}
1467DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1468
1469static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1470	struct se_ml_stat_grps *lgrps, char *page)
1471{
1472	struct se_lun_acl *lacl = container_of(lgrps,
1473			struct se_lun_acl, ml_stat_grps);
1474	struct se_node_acl *nacl = lacl->se_lun_nacl;
1475	struct se_dev_entry *deve;
1476	struct se_lun *lun;
 
1477	ssize_t ret;
1478
1479	spin_lock_irq(&nacl->device_list_lock);
1480	deve = nacl->device_list[lacl->mapped_lun];
1481	if (!deve->se_lun || !deve->se_lun_acl) {
1482		spin_unlock_irq(&nacl->device_list_lock);
1483		return -ENODEV;
1484	}
 
1485	lun = deve->se_lun;
1486	/* scsiDeviceIndex */
1487	ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1488	spin_unlock_irq(&nacl->device_list_lock);
1489	return ret;
1490}
1491DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1492
1493static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1494	struct se_ml_stat_grps *lgrps, char *page)
1495{
1496	struct se_lun_acl *lacl = container_of(lgrps,
1497			struct se_lun_acl, ml_stat_grps);
1498	struct se_node_acl *nacl = lacl->se_lun_nacl;
1499	struct se_dev_entry *deve;
1500	struct se_portal_group *tpg;
1501	ssize_t ret;
1502
1503	spin_lock_irq(&nacl->device_list_lock);
1504	deve = nacl->device_list[lacl->mapped_lun];
1505	if (!deve->se_lun || !deve->se_lun_acl) {
1506		spin_unlock_irq(&nacl->device_list_lock);
1507		return -ENODEV;
1508	}
1509	tpg = nacl->se_tpg;
1510	/* scsiPortIndex */
1511	ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1512	spin_unlock_irq(&nacl->device_list_lock);
1513	return ret;
1514}
1515DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1516
1517static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1518	struct se_ml_stat_grps *lgrps, char *page)
1519{
1520	struct se_lun_acl *lacl = container_of(lgrps,
1521			struct se_lun_acl, ml_stat_grps);
1522	struct se_node_acl *nacl = lacl->se_lun_nacl;
1523	struct se_session *se_sess;
1524	struct se_portal_group *tpg;
1525	ssize_t ret;
1526
1527	spin_lock_irq(&nacl->nacl_sess_lock);
1528	se_sess = nacl->nacl_sess;
1529	if (!se_sess) {
1530		spin_unlock_irq(&nacl->nacl_sess_lock);
1531		return -ENODEV;
1532	}
1533
1534	tpg = nacl->se_tpg;
1535	/* scsiAttIntrPortIndex */
1536	ret = snprintf(page, PAGE_SIZE, "%u\n",
1537			tpg->se_tpg_tfo->sess_get_index(se_sess));
1538	spin_unlock_irq(&nacl->nacl_sess_lock);
1539	return ret;
1540}
1541DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1542
1543static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1544	struct se_ml_stat_grps *lgrps, char *page)
1545{
1546	struct se_lun_acl *lacl = container_of(lgrps,
1547			struct se_lun_acl, ml_stat_grps);
1548	struct se_node_acl *nacl = lacl->se_lun_nacl;
1549	struct se_dev_entry *deve;
1550	ssize_t ret;
1551
1552	spin_lock_irq(&nacl->device_list_lock);
1553	deve = nacl->device_list[lacl->mapped_lun];
1554	if (!deve->se_lun || !deve->se_lun_acl) {
1555		spin_unlock_irq(&nacl->device_list_lock);
1556		return -ENODEV;
1557	}
1558	/* scsiAttIntrPortAuthIntrIdx */
1559	ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1560	spin_unlock_irq(&nacl->device_list_lock);
1561	return ret;
1562}
1563DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1564
1565static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1566	struct se_ml_stat_grps *lgrps, char *page)
1567{
1568	struct se_lun_acl *lacl = container_of(lgrps,
1569			struct se_lun_acl, ml_stat_grps);
1570	struct se_node_acl *nacl = lacl->se_lun_nacl;
1571	struct se_session *se_sess;
1572	struct se_portal_group *tpg;
1573	ssize_t ret;
1574	unsigned char buf[64];
1575
1576	spin_lock_irq(&nacl->nacl_sess_lock);
1577	se_sess = nacl->nacl_sess;
1578	if (!se_sess) {
1579		spin_unlock_irq(&nacl->nacl_sess_lock);
1580		return -ENODEV;
1581	}
1582
1583	tpg = nacl->se_tpg;
1584	/* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1585	memset(buf, 0, 64);
1586	if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1587		tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
 
1588
1589	ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1590	spin_unlock_irq(&nacl->nacl_sess_lock);
1591	return ret;
1592}
1593DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1594
1595CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1596		scsi_att_intr_port_group);
1597
1598static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1599	&target_stat_scsi_att_intr_port_inst.attr,
1600	&target_stat_scsi_att_intr_port_dev.attr,
1601	&target_stat_scsi_att_intr_port_port.attr,
1602	&target_stat_scsi_att_intr_port_indx.attr,
1603	&target_stat_scsi_att_intr_port_port_auth_indx.attr,
1604	&target_stat_scsi_att_intr_port_port_ident.attr,
1605	NULL,
1606};
1607
1608static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1609	.show_attribute		= target_stat_scsi_att_intr_port_attr_show,
1610	.store_attribute	= target_stat_scsi_att_intr_port_attr_store,
1611};
1612
1613static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1614	.ct_item_ops		= &target_stat_scsi_att_intr_port_attrib_ops,
1615	.ct_attrs		= target_stat_scsi_ath_intr_port_attrs,
1616	.ct_owner		= THIS_MODULE,
1617};
1618
1619/*
1620 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1621 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1622 */
1623void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1624{
1625	struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1626
1627	config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1628			"scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1629	config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1630			"scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1631
1632	ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1633	ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1634	ml_stat_grp->default_groups[2] = NULL;
1635}