blob: 237309db4b3323372e4adaec778e38cfb0761675 [file] [log] [blame]
Thomas Gleixner1a59d1b82019-05-27 08:55:05 +02001// SPDX-License-Identifier: GPL-2.0-or-later
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07002/*******************************************************************************
3 * Filename: target_core_stat.c
4 *
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07005 * Modern ConfigFS group context specific statistics based on original
6 * target_core_mib.c code
7 *
Nicholas Bellinger4c762512013-09-05 15:29:12 -07008 * (c) Copyright 2006-2013 Datera, Inc.
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07009 *
10 * Nicholas A. Bellinger <nab@linux-iscsi.org>
11 *
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070012 ******************************************************************************/
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/delay.h>
17#include <linux/timer.h>
18#include <linux/string.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070019#include <linux/utsname.h>
20#include <linux/proc_fs.h>
21#include <linux/seq_file.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070022#include <linux/configfs.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070023
24#include <target/target_core_base.h>
Christoph Hellwigc4795fb2011-11-16 09:46:48 -050025#include <target/target_core_backend.h>
26#include <target/target_core_fabric.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070027
Christoph Hellwige26d99a2011-11-14 12:30:30 -050028#include "target_core_internal.h"
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070029
30#ifndef INITIAL_JIFFIES
31#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
32#endif
33
34#define NONE "None"
35#define ISPRINT(a) ((a >= ' ') && (a <= '~'))
36
37#define SCSI_LU_INDEX 1
38#define LU_COUNT 1
39
40/*
41 * SCSI Device Table
42 */
43
Christoph Hellwig2eafd722015-10-03 15:32:55 +020044static struct se_device *to_stat_dev(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070045{
Christoph Hellwig2eafd722015-10-03 15:32:55 +020046 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
47 struct se_dev_stat_grps, scsi_dev_group);
48 return container_of(sgrps, struct se_device, dev_stat_grps);
49}
50
51static ssize_t target_stat_inst_show(struct config_item *item, char *page)
52{
53 struct se_hba *hba = to_stat_dev(item)->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070054
55 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
56}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070057
Christoph Hellwig2eafd722015-10-03 15:32:55 +020058static ssize_t target_stat_indx_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070059{
Christoph Hellwig2eafd722015-10-03 15:32:55 +020060 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->dev_index);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070061}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070062
Christoph Hellwig2eafd722015-10-03 15:32:55 +020063static ssize_t target_stat_role_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070064{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070065 return snprintf(page, PAGE_SIZE, "Target\n");
66}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070067
Christoph Hellwig2eafd722015-10-03 15:32:55 +020068static ssize_t target_stat_ports_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070069{
Christoph Hellwig2eafd722015-10-03 15:32:55 +020070 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->export_count);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070071}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070072
Christoph Hellwig2eafd722015-10-03 15:32:55 +020073CONFIGFS_ATTR_RO(target_stat_, inst);
74CONFIGFS_ATTR_RO(target_stat_, indx);
75CONFIGFS_ATTR_RO(target_stat_, role);
76CONFIGFS_ATTR_RO(target_stat_, ports);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070077
78static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +020079 &target_stat_attr_inst,
80 &target_stat_attr_indx,
81 &target_stat_attr_role,
82 &target_stat_attr_ports,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070083 NULL,
84};
85
Bhumika Goyalece550b2017-10-16 17:18:42 +020086static const struct config_item_type target_stat_scsi_dev_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070087 .ct_attrs = target_stat_scsi_dev_attrs,
88 .ct_owner = THIS_MODULE,
89};
90
91/*
92 * SCSI Target Device Table
93 */
Christoph Hellwig2eafd722015-10-03 15:32:55 +020094static struct se_device *to_stat_tgt_dev(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070095{
Christoph Hellwig2eafd722015-10-03 15:32:55 +020096 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
97 struct se_dev_stat_grps, scsi_tgt_dev_group);
98 return container_of(sgrps, struct se_device, dev_stat_grps);
99}
100
101static ssize_t target_stat_tgt_inst_show(struct config_item *item, char *page)
102{
103 struct se_hba *hba = to_stat_tgt_dev(item)->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700104
105 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
106}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700107
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200108static ssize_t target_stat_tgt_indx_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700109{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200110 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_tgt_dev(item)->dev_index);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700111}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700112
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200113static ssize_t target_stat_tgt_num_lus_show(struct config_item *item,
114 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700115{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700116 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
117}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700118
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200119static ssize_t target_stat_tgt_status_show(struct config_item *item,
120 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700121{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200122 if (to_stat_tgt_dev(item)->export_count)
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400123 return snprintf(page, PAGE_SIZE, "activated");
124 else
125 return snprintf(page, PAGE_SIZE, "deactivated");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700126}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700127
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200128static ssize_t target_stat_tgt_non_access_lus_show(struct config_item *item,
129 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700130{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700131 int non_accessible_lus;
132
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200133 if (to_stat_tgt_dev(item)->export_count)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700134 non_accessible_lus = 0;
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400135 else
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700136 non_accessible_lus = 1;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700137
138 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
139}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700140
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200141static ssize_t target_stat_tgt_resets_show(struct config_item *item,
142 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700143{
Nicholas Bellingeree480682013-11-13 18:34:55 -0800144 return snprintf(page, PAGE_SIZE, "%lu\n",
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200145 atomic_long_read(&to_stat_tgt_dev(item)->num_resets));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700146}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700147
Nicholas Bellingerc87ba9c2017-01-19 15:45:57 -0800148static ssize_t target_stat_tgt_aborts_complete_show(struct config_item *item,
149 char *page)
150{
151 return snprintf(page, PAGE_SIZE, "%lu\n",
152 atomic_long_read(&to_stat_tgt_dev(item)->aborts_complete));
153}
154
155static ssize_t target_stat_tgt_aborts_no_task_show(struct config_item *item,
156 char *page)
157{
158 return snprintf(page, PAGE_SIZE, "%lu\n",
159 atomic_long_read(&to_stat_tgt_dev(item)->aborts_no_task));
160}
161
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200162CONFIGFS_ATTR_RO(target_stat_tgt_, inst);
163CONFIGFS_ATTR_RO(target_stat_tgt_, indx);
164CONFIGFS_ATTR_RO(target_stat_tgt_, num_lus);
165CONFIGFS_ATTR_RO(target_stat_tgt_, status);
166CONFIGFS_ATTR_RO(target_stat_tgt_, non_access_lus);
167CONFIGFS_ATTR_RO(target_stat_tgt_, resets);
Nicholas Bellingerc87ba9c2017-01-19 15:45:57 -0800168CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_complete);
169CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_no_task);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700170
171static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200172 &target_stat_tgt_attr_inst,
173 &target_stat_tgt_attr_indx,
174 &target_stat_tgt_attr_num_lus,
175 &target_stat_tgt_attr_status,
176 &target_stat_tgt_attr_non_access_lus,
177 &target_stat_tgt_attr_resets,
Nicholas Bellingerc87ba9c2017-01-19 15:45:57 -0800178 &target_stat_tgt_attr_aborts_complete,
179 &target_stat_tgt_attr_aborts_no_task,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700180 NULL,
181};
182
Bhumika Goyalece550b2017-10-16 17:18:42 +0200183static const struct config_item_type target_stat_scsi_tgt_dev_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700184 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
185 .ct_owner = THIS_MODULE,
186};
187
188/*
189 * SCSI Logical Unit Table
190 */
191
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200192static struct se_device *to_stat_lu_dev(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700193{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200194 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
195 struct se_dev_stat_grps, scsi_lu_group);
196 return container_of(sgrps, struct se_device, dev_stat_grps);
197}
198
199static ssize_t target_stat_lu_inst_show(struct config_item *item, char *page)
200{
201 struct se_hba *hba = to_stat_lu_dev(item)->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700202
203 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
204}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700205
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200206static ssize_t target_stat_lu_dev_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700207{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200208 return snprintf(page, PAGE_SIZE, "%u\n",
209 to_stat_lu_dev(item)->dev_index);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700210}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700211
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200212static ssize_t target_stat_lu_indx_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700213{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700214 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
215}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700216
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200217static ssize_t target_stat_lu_lun_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700218{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700219 /* FIXME: scsiLuDefaultLun */
220 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
221}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700222
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200223static ssize_t target_stat_lu_lu_name_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700224{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200225 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700226
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700227 /* scsiLuWwnName */
228 return snprintf(page, PAGE_SIZE, "%s\n",
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400229 (strlen(dev->t10_wwn.unit_serial)) ?
230 dev->t10_wwn.unit_serial : "None");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700231}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700232
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200233static ssize_t target_stat_lu_vend_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700234{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200235 struct se_device *dev = to_stat_lu_dev(item);
Andy Grovere3d6f902011-07-19 08:55:10 +0000236
David Disseldorpb2da4ab2018-12-05 13:18:35 +0100237 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_VENDOR_LEN)
238 "s\n", dev->t10_wwn.vendor);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700239}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700240
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200241static ssize_t target_stat_lu_prod_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700242{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200243 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700244
David Disseldorpb2da4ab2018-12-05 13:18:35 +0100245 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_MODEL_LEN)
246 "s\n", dev->t10_wwn.model);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700247}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700248
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200249static ssize_t target_stat_lu_rev_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700250{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200251 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700252
David Disseldorpb2da4ab2018-12-05 13:18:35 +0100253 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_REVISION_LEN)
254 "s\n", dev->t10_wwn.revision);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700255}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700256
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200257static ssize_t target_stat_lu_dev_type_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700258{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200259 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700260
261 /* scsiLuPeripheralType */
262 return snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +0000263 dev->transport->get_device_type(dev));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700264}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700265
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200266static ssize_t target_stat_lu_status_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700267{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200268 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700269
270 /* scsiLuStatus */
271 return snprintf(page, PAGE_SIZE, "%s\n",
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400272 (dev->export_count) ? "available" : "notavailable");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700273}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700274
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200275static ssize_t target_stat_lu_state_bit_show(struct config_item *item,
276 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700277{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700278 /* scsiLuState */
279 return snprintf(page, PAGE_SIZE, "exposed\n");
280}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700281
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200282static ssize_t target_stat_lu_num_cmds_show(struct config_item *item,
283 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700284{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200285 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700286
287 /* scsiLuNumCommands */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800288 return snprintf(page, PAGE_SIZE, "%lu\n",
289 atomic_long_read(&dev->num_cmds));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700290}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700291
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200292static ssize_t target_stat_lu_read_mbytes_show(struct config_item *item,
293 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700294{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200295 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700296
297 /* scsiLuReadMegaBytes */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800298 return snprintf(page, PAGE_SIZE, "%lu\n",
299 atomic_long_read(&dev->read_bytes) >> 20);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700300}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700301
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200302static ssize_t target_stat_lu_write_mbytes_show(struct config_item *item,
303 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700304{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200305 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700306
307 /* scsiLuWrittenMegaBytes */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800308 return snprintf(page, PAGE_SIZE, "%lu\n",
309 atomic_long_read(&dev->write_bytes) >> 20);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700310}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700311
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200312static ssize_t target_stat_lu_resets_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700313{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200314 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700315
316 /* scsiLuInResets */
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200317 return snprintf(page, PAGE_SIZE, "%lu\n",
318 atomic_long_read(&dev->num_resets));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700319}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700320
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200321static ssize_t target_stat_lu_full_stat_show(struct config_item *item,
322 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700323{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700324 /* FIXME: scsiLuOutTaskSetFullStatus */
325 return snprintf(page, PAGE_SIZE, "%u\n", 0);
326}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700327
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200328static ssize_t target_stat_lu_hs_num_cmds_show(struct config_item *item,
329 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700330{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700331 /* FIXME: scsiLuHSInCommands */
332 return snprintf(page, PAGE_SIZE, "%u\n", 0);
333}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700334
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200335static ssize_t target_stat_lu_creation_time_show(struct config_item *item,
336 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700337{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200338 struct se_device *dev = to_stat_lu_dev(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700339
340 /* scsiLuCreationTime */
341 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
342 INITIAL_JIFFIES) * 100 / HZ));
343}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700344
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200345CONFIGFS_ATTR_RO(target_stat_lu_, inst);
346CONFIGFS_ATTR_RO(target_stat_lu_, dev);
347CONFIGFS_ATTR_RO(target_stat_lu_, indx);
348CONFIGFS_ATTR_RO(target_stat_lu_, lun);
349CONFIGFS_ATTR_RO(target_stat_lu_, lu_name);
350CONFIGFS_ATTR_RO(target_stat_lu_, vend);
351CONFIGFS_ATTR_RO(target_stat_lu_, prod);
352CONFIGFS_ATTR_RO(target_stat_lu_, rev);
353CONFIGFS_ATTR_RO(target_stat_lu_, dev_type);
354CONFIGFS_ATTR_RO(target_stat_lu_, status);
355CONFIGFS_ATTR_RO(target_stat_lu_, state_bit);
356CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds);
357CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes);
358CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes);
359CONFIGFS_ATTR_RO(target_stat_lu_, resets);
360CONFIGFS_ATTR_RO(target_stat_lu_, full_stat);
361CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds);
362CONFIGFS_ATTR_RO(target_stat_lu_, creation_time);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700363
364static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200365 &target_stat_lu_attr_inst,
366 &target_stat_lu_attr_dev,
367 &target_stat_lu_attr_indx,
368 &target_stat_lu_attr_lun,
369 &target_stat_lu_attr_lu_name,
370 &target_stat_lu_attr_vend,
371 &target_stat_lu_attr_prod,
372 &target_stat_lu_attr_rev,
373 &target_stat_lu_attr_dev_type,
374 &target_stat_lu_attr_status,
375 &target_stat_lu_attr_state_bit,
376 &target_stat_lu_attr_num_cmds,
377 &target_stat_lu_attr_read_mbytes,
378 &target_stat_lu_attr_write_mbytes,
379 &target_stat_lu_attr_resets,
380 &target_stat_lu_attr_full_stat,
381 &target_stat_lu_attr_hs_num_cmds,
382 &target_stat_lu_attr_creation_time,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700383 NULL,
384};
385
Bhumika Goyalece550b2017-10-16 17:18:42 +0200386static const struct config_item_type target_stat_scsi_lu_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700387 .ct_attrs = target_stat_scsi_lu_attrs,
388 .ct_owner = THIS_MODULE,
389};
390
391/*
392 * Called from target_core_configfs.c:target_core_make_subdev() to setup
393 * the target statistics groups + configfs CITs located in target_core_stat.c
394 */
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400395void target_stat_setup_dev_default_groups(struct se_device *dev)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700396{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400397 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700398 "scsi_dev", &target_stat_scsi_dev_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100399 configfs_add_default_group(&dev->dev_stat_grps.scsi_dev_group,
400 &dev->dev_stat_grps.stat_group);
401
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400402 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700403 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100404 configfs_add_default_group(&dev->dev_stat_grps.scsi_tgt_dev_group,
405 &dev->dev_stat_grps.stat_group);
406
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400407 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700408 "scsi_lu", &target_stat_scsi_lu_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100409 configfs_add_default_group(&dev->dev_stat_grps.scsi_lu_group,
410 &dev->dev_stat_grps.stat_group);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700411}
412
413/*
414 * SCSI Port Table
415 */
416
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200417static struct se_lun *to_stat_port(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700418{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200419 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
420 struct se_port_stat_grps, scsi_port_group);
421 return container_of(pgrps, struct se_lun, port_stat_grps);
422}
423
424static ssize_t target_stat_port_inst_show(struct config_item *item, char *page)
425{
426 struct se_lun *lun = to_stat_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700427 struct se_device *dev;
428 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700429
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700430 rcu_read_lock();
431 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700432 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700433 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
434 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700435 return ret;
436}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700437
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200438static ssize_t target_stat_port_dev_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700439{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200440 struct se_lun *lun = to_stat_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700441 struct se_device *dev;
442 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700443
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700444 rcu_read_lock();
445 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700446 if (dev)
447 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700448 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700449 return ret;
450}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700451
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200452static ssize_t target_stat_port_indx_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700453{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200454 struct se_lun *lun = to_stat_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700455 struct se_device *dev;
456 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700457
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700458 rcu_read_lock();
459 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700460 if (dev)
461 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700462 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700463 return ret;
464}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700465
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200466static ssize_t target_stat_port_role_show(struct config_item *item, char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700467{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200468 struct se_lun *lun = to_stat_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700469 struct se_device *dev;
470 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700471
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700472 rcu_read_lock();
473 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700474 if (dev)
475 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700476 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700477 return ret;
478}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700479
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200480static ssize_t target_stat_port_busy_count_show(struct config_item *item,
481 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700482{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200483 struct se_lun *lun = to_stat_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700484 struct se_device *dev;
485 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700486
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700487 rcu_read_lock();
488 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700489 if (dev) {
490 /* FIXME: scsiPortBusyStatuses */
491 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700492 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700493 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700494 return ret;
495}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700496
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200497CONFIGFS_ATTR_RO(target_stat_port_, inst);
498CONFIGFS_ATTR_RO(target_stat_port_, dev);
499CONFIGFS_ATTR_RO(target_stat_port_, indx);
500CONFIGFS_ATTR_RO(target_stat_port_, role);
501CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700502
503static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200504 &target_stat_port_attr_inst,
505 &target_stat_port_attr_dev,
506 &target_stat_port_attr_indx,
507 &target_stat_port_attr_role,
508 &target_stat_port_attr_busy_count,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700509 NULL,
510};
511
Bhumika Goyalece550b2017-10-16 17:18:42 +0200512static const struct config_item_type target_stat_scsi_port_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700513 .ct_attrs = target_stat_scsi_port_attrs,
514 .ct_owner = THIS_MODULE,
515};
516
517/*
518 * SCSI Target Port Table
519 */
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200520static struct se_lun *to_stat_tgt_port(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700521{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200522 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
523 struct se_port_stat_grps, scsi_tgt_port_group);
524 return container_of(pgrps, struct se_lun, port_stat_grps);
525}
526
527static ssize_t target_stat_tgt_port_inst_show(struct config_item *item,
528 char *page)
529{
530 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700531 struct se_device *dev;
532 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700533
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700534 rcu_read_lock();
535 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700536 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700537 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
538 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700539 return ret;
540}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700541
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200542static ssize_t target_stat_tgt_port_dev_show(struct config_item *item,
543 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700544{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200545 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700546 struct se_device *dev;
547 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700548
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700549 rcu_read_lock();
550 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700551 if (dev)
552 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700553 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700554 return ret;
555}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700556
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200557static ssize_t target_stat_tgt_port_indx_show(struct config_item *item,
558 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700559{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200560 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700561 struct se_device *dev;
562 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700563
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700564 rcu_read_lock();
565 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700566 if (dev)
567 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700568 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700569 return ret;
570}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700571
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200572static ssize_t target_stat_tgt_port_name_show(struct config_item *item,
573 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700574{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200575 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700576 struct se_portal_group *tpg = lun->lun_tpg;
577 struct se_device *dev;
578 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700579
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700580 rcu_read_lock();
581 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700582 if (dev)
583 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
David Disseldorp30c7ca92018-11-23 18:36:12 +0100584 tpg->se_tpg_tfo->fabric_name,
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700585 lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700586 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700587 return ret;
588}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700589
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200590static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item,
591 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700592{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200593 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700594 struct se_portal_group *tpg = lun->lun_tpg;
595 struct se_device *dev;
596 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700597
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700598 rcu_read_lock();
599 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700600 if (dev)
601 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
602 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
603 tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700604 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700605 return ret;
606}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700607
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200608static ssize_t target_stat_tgt_port_in_cmds_show(struct config_item *item,
609 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700610{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200611 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700612 struct se_device *dev;
613 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700614
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700615 rcu_read_lock();
616 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700617 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700618 ret = snprintf(page, PAGE_SIZE, "%lu\n",
619 atomic_long_read(&lun->lun_stats.cmd_pdus));
620 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700621 return ret;
622}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700623
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200624static ssize_t target_stat_tgt_port_write_mbytes_show(struct config_item *item,
625 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700626{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200627 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700628 struct se_device *dev;
629 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700630
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700631 rcu_read_lock();
632 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700633 if (dev)
634 ret = snprintf(page, PAGE_SIZE, "%u\n",
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700635 (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
636 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700637 return ret;
638}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700639
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200640static ssize_t target_stat_tgt_port_read_mbytes_show(struct config_item *item,
641 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700642{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200643 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700644 struct se_device *dev;
645 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700646
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700647 rcu_read_lock();
648 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700649 if (dev)
650 ret = snprintf(page, PAGE_SIZE, "%u\n",
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700651 (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
652 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700653 return ret;
654}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700655
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200656static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item,
657 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700658{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200659 struct se_lun *lun = to_stat_tgt_port(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700660 struct se_device *dev;
661 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700662
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700663 rcu_read_lock();
664 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700665 if (dev) {
666 /* FIXME: scsiTgtPortHsInCommands */
667 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700668 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700669 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700670 return ret;
671}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700672
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200673CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
674CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
675CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
676CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
677CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
678CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
679CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
680CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
681CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700682
683static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200684 &target_stat_tgt_port_attr_inst,
685 &target_stat_tgt_port_attr_dev,
686 &target_stat_tgt_port_attr_indx,
687 &target_stat_tgt_port_attr_name,
688 &target_stat_tgt_port_attr_port_index,
689 &target_stat_tgt_port_attr_in_cmds,
690 &target_stat_tgt_port_attr_write_mbytes,
691 &target_stat_tgt_port_attr_read_mbytes,
692 &target_stat_tgt_port_attr_hs_in_cmds,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700693 NULL,
694};
695
Bhumika Goyalece550b2017-10-16 17:18:42 +0200696static const struct config_item_type target_stat_scsi_tgt_port_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700697 .ct_attrs = target_stat_scsi_tgt_port_attrs,
698 .ct_owner = THIS_MODULE,
699};
700
701/*
702 * SCSI Transport Table
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200703 */
704static struct se_lun *to_transport_stat(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700705{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200706 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
707 struct se_port_stat_grps, scsi_transport_group);
708 return container_of(pgrps, struct se_lun, port_stat_grps);
709}
710
711static ssize_t target_stat_transport_inst_show(struct config_item *item,
712 char *page)
713{
714 struct se_lun *lun = to_transport_stat(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700715 struct se_device *dev;
716 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700717
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700718 rcu_read_lock();
719 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700720 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700721 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
722 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700723 return ret;
724}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700725
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200726static ssize_t target_stat_transport_device_show(struct config_item *item,
727 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700728{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200729 struct se_lun *lun = to_transport_stat(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700730 struct se_device *dev;
731 struct se_portal_group *tpg = lun->lun_tpg;
732 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700733
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700734 rcu_read_lock();
735 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700736 if (dev) {
737 /* scsiTransportType */
738 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
David Disseldorp30c7ca92018-11-23 18:36:12 +0100739 tpg->se_tpg_tfo->fabric_name);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700740 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700741 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700742 return ret;
743}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700744
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200745static ssize_t target_stat_transport_indx_show(struct config_item *item,
746 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700747{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200748 struct se_lun *lun = to_transport_stat(item);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700749 struct se_device *dev;
750 struct se_portal_group *tpg = lun->lun_tpg;
751 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700752
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700753 rcu_read_lock();
754 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700755 if (dev)
756 ret = snprintf(page, PAGE_SIZE, "%u\n",
757 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700758 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700759 return ret;
760}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700761
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200762static ssize_t target_stat_transport_dev_name_show(struct config_item *item,
763 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700764{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200765 struct se_lun *lun = to_transport_stat(item);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700766 struct se_device *dev;
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700767 struct se_portal_group *tpg = lun->lun_tpg;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700768 struct t10_wwn *wwn;
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700769 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700770
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700771 rcu_read_lock();
772 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700773 if (dev) {
774 wwn = &dev->t10_wwn;
775 /* scsiTransportDevName */
776 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
777 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
778 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
779 wwn->vendor);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700780 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700781 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700782 return ret;
783}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700784
Mike Christie0ab8ac62017-01-13 04:47:48 -0600785static ssize_t target_stat_transport_proto_id_show(struct config_item *item,
786 char *page)
787{
788 struct se_lun *lun = to_transport_stat(item);
789 struct se_device *dev;
790 struct se_portal_group *tpg = lun->lun_tpg;
791 ssize_t ret = -ENODEV;
792
793 rcu_read_lock();
794 dev = rcu_dereference(lun->lun_se_dev);
795 if (dev)
796 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->proto_id);
797 rcu_read_unlock();
798 return ret;
799}
800
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200801CONFIGFS_ATTR_RO(target_stat_transport_, inst);
802CONFIGFS_ATTR_RO(target_stat_transport_, device);
803CONFIGFS_ATTR_RO(target_stat_transport_, indx);
804CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
Mike Christie0ab8ac62017-01-13 04:47:48 -0600805CONFIGFS_ATTR_RO(target_stat_transport_, proto_id);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700806
807static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200808 &target_stat_transport_attr_inst,
809 &target_stat_transport_attr_device,
810 &target_stat_transport_attr_indx,
811 &target_stat_transport_attr_dev_name,
Mike Christie0ab8ac62017-01-13 04:47:48 -0600812 &target_stat_transport_attr_proto_id,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700813 NULL,
814};
815
Bhumika Goyalece550b2017-10-16 17:18:42 +0200816static const struct config_item_type target_stat_scsi_transport_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700817 .ct_attrs = target_stat_scsi_transport_attrs,
818 .ct_owner = THIS_MODULE,
819};
820
821/*
822 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
823 * the target port statistics groups + configfs CITs located in target_core_stat.c
824 */
825void target_stat_setup_port_default_groups(struct se_lun *lun)
826{
Andy Grovere3d6f902011-07-19 08:55:10 +0000827 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700828 "scsi_port", &target_stat_scsi_port_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100829 configfs_add_default_group(&lun->port_stat_grps.scsi_port_group,
830 &lun->port_stat_grps.stat_group);
831
Andy Grovere3d6f902011-07-19 08:55:10 +0000832 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700833 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100834 configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group,
835 &lun->port_stat_grps.stat_group);
836
Andy Grovere3d6f902011-07-19 08:55:10 +0000837 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700838 "scsi_transport", &target_stat_scsi_transport_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +0100839 configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group,
840 &lun->port_stat_grps.stat_group);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700841}
842
843/*
844 * SCSI Authorized Initiator Table
845 */
846
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200847static struct se_lun_acl *auth_to_lacl(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700848{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200849 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
850 struct se_ml_stat_grps, scsi_auth_intr_group);
851 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
852}
853
854static ssize_t target_stat_auth_inst_show(struct config_item *item,
855 char *page)
856{
857 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700858 struct se_node_acl *nacl = lacl->se_lun_nacl;
859 struct se_dev_entry *deve;
860 struct se_portal_group *tpg;
861 ssize_t ret;
862
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700863 rcu_read_lock();
864 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
865 if (!deve) {
866 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700867 return -ENODEV;
868 }
869 tpg = nacl->se_tpg;
870 /* scsiInstIndex */
871 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +0000872 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700873 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700874 return ret;
875}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700876
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200877static ssize_t target_stat_auth_dev_show(struct config_item *item,
878 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700879{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200880 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700881 struct se_node_acl *nacl = lacl->se_lun_nacl;
882 struct se_dev_entry *deve;
883 struct se_lun *lun;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700884 ssize_t ret;
885
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700886 rcu_read_lock();
887 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
888 if (!deve) {
889 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700890 return -ENODEV;
891 }
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700892 lun = rcu_dereference(deve->se_lun);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700893 /* scsiDeviceIndex */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700894 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
895 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700896 return ret;
897}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700898
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200899static ssize_t target_stat_auth_port_show(struct config_item *item,
900 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700901{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200902 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700903 struct se_node_acl *nacl = lacl->se_lun_nacl;
904 struct se_dev_entry *deve;
905 struct se_portal_group *tpg;
906 ssize_t ret;
907
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700908 rcu_read_lock();
909 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
910 if (!deve) {
911 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700912 return -ENODEV;
913 }
914 tpg = nacl->se_tpg;
915 /* scsiAuthIntrTgtPortIndex */
Andy Grovere3d6f902011-07-19 08:55:10 +0000916 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700917 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700918 return ret;
919}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700920
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200921static ssize_t target_stat_auth_indx_show(struct config_item *item,
922 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700923{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200924 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700925 struct se_node_acl *nacl = lacl->se_lun_nacl;
926 struct se_dev_entry *deve;
927 ssize_t ret;
928
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700929 rcu_read_lock();
930 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
931 if (!deve) {
932 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700933 return -ENODEV;
934 }
935 /* scsiAuthIntrIndex */
936 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700937 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700938 return ret;
939}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700940
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200941static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
942 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700943{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200944 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700945 struct se_node_acl *nacl = lacl->se_lun_nacl;
946 struct se_dev_entry *deve;
947 ssize_t ret;
948
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700949 rcu_read_lock();
950 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
951 if (!deve) {
952 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700953 return -ENODEV;
954 }
955 /* scsiAuthIntrDevOrPort */
956 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700957 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700958 return ret;
959}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700960
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200961static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
962 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700963{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200964 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700965 struct se_node_acl *nacl = lacl->se_lun_nacl;
966 struct se_dev_entry *deve;
967 ssize_t ret;
968
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700969 rcu_read_lock();
970 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
971 if (!deve) {
972 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700973 return -ENODEV;
974 }
975 /* scsiAuthIntrName */
976 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700977 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700978 return ret;
979}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700980
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200981static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
982 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700983{
Christoph Hellwig2eafd722015-10-03 15:32:55 +0200984 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700985 struct se_node_acl *nacl = lacl->se_lun_nacl;
986 struct se_dev_entry *deve;
987 ssize_t ret;
988
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700989 rcu_read_lock();
990 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
991 if (!deve) {
992 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700993 return -ENODEV;
994 }
995 /* FIXME: scsiAuthIntrLunMapIndex */
996 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -0700997 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700998 return ret;
999}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001000
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001001static ssize_t target_stat_auth_att_count_show(struct config_item *item,
1002 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001003{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001004 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001005 struct se_node_acl *nacl = lacl->se_lun_nacl;
1006 struct se_dev_entry *deve;
1007 ssize_t ret;
1008
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001009 rcu_read_lock();
1010 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1011 if (!deve) {
1012 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001013 return -ENODEV;
1014 }
1015 /* scsiAuthIntrAttachedTimes */
1016 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001017 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001018 return ret;
1019}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001020
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001021static ssize_t target_stat_auth_num_cmds_show(struct config_item *item,
1022 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001023{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001024 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001025 struct se_node_acl *nacl = lacl->se_lun_nacl;
1026 struct se_dev_entry *deve;
1027 ssize_t ret;
1028
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001029 rcu_read_lock();
1030 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1031 if (!deve) {
1032 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001033 return -ENODEV;
1034 }
1035 /* scsiAuthIntrOutCommands */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001036 ret = snprintf(page, PAGE_SIZE, "%lu\n",
1037 atomic_long_read(&deve->total_cmds));
1038 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001039 return ret;
1040}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001041
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001042static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item,
1043 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001044{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001045 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001046 struct se_node_acl *nacl = lacl->se_lun_nacl;
1047 struct se_dev_entry *deve;
1048 ssize_t ret;
1049
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001050 rcu_read_lock();
1051 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1052 if (!deve) {
1053 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001054 return -ENODEV;
1055 }
1056 /* scsiAuthIntrReadMegaBytes */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001057 ret = snprintf(page, PAGE_SIZE, "%u\n",
1058 (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1059 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001060 return ret;
1061}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001062
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001063static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item,
1064 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001065{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001066 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001067 struct se_node_acl *nacl = lacl->se_lun_nacl;
1068 struct se_dev_entry *deve;
1069 ssize_t ret;
1070
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001071 rcu_read_lock();
1072 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1073 if (!deve) {
1074 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001075 return -ENODEV;
1076 }
1077 /* scsiAuthIntrWrittenMegaBytes */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001078 ret = snprintf(page, PAGE_SIZE, "%u\n",
1079 (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1080 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001081 return ret;
1082}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001083
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001084static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1085 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001086{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001087 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001088 struct se_node_acl *nacl = lacl->se_lun_nacl;
1089 struct se_dev_entry *deve;
1090 ssize_t ret;
1091
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001092 rcu_read_lock();
1093 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1094 if (!deve) {
1095 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001096 return -ENODEV;
1097 }
1098 /* FIXME: scsiAuthIntrHSOutCommands */
1099 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001100 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001101 return ret;
1102}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001103
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001104static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1105 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001106{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001107 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001108 struct se_node_acl *nacl = lacl->se_lun_nacl;
1109 struct se_dev_entry *deve;
1110 ssize_t ret;
1111
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001112 rcu_read_lock();
1113 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1114 if (!deve) {
1115 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001116 return -ENODEV;
1117 }
1118 /* scsiAuthIntrLastCreation */
1119 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1120 INITIAL_JIFFIES) * 100 / HZ));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001121 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001122 return ret;
1123}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001124
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001125static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1126 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001127{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001128 struct se_lun_acl *lacl = auth_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001129 struct se_node_acl *nacl = lacl->se_lun_nacl;
1130 struct se_dev_entry *deve;
1131 ssize_t ret;
1132
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001133 rcu_read_lock();
1134 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1135 if (!deve) {
1136 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001137 return -ENODEV;
1138 }
1139 /* FIXME: scsiAuthIntrRowStatus */
1140 ret = snprintf(page, PAGE_SIZE, "Ready\n");
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001141 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001142 return ret;
1143}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001144
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001145CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1146CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1147CONFIGFS_ATTR_RO(target_stat_auth_, port);
1148CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1149CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1150CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1151CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1152CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1153CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1154CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1155CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1156CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1157CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1158CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001159
1160static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001161 &target_stat_auth_attr_inst,
1162 &target_stat_auth_attr_dev,
1163 &target_stat_auth_attr_port,
1164 &target_stat_auth_attr_indx,
1165 &target_stat_auth_attr_dev_or_port,
1166 &target_stat_auth_attr_intr_name,
1167 &target_stat_auth_attr_map_indx,
1168 &target_stat_auth_attr_att_count,
1169 &target_stat_auth_attr_num_cmds,
1170 &target_stat_auth_attr_read_mbytes,
1171 &target_stat_auth_attr_write_mbytes,
1172 &target_stat_auth_attr_hs_num_cmds,
1173 &target_stat_auth_attr_creation_time,
1174 &target_stat_auth_attr_row_status,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001175 NULL,
1176};
1177
Bhumika Goyalece550b2017-10-16 17:18:42 +02001178static const struct config_item_type target_stat_scsi_auth_intr_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001179 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1180 .ct_owner = THIS_MODULE,
1181};
1182
1183/*
1184 * SCSI Attached Initiator Port Table
1185 */
1186
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001187static struct se_lun_acl *iport_to_lacl(struct config_item *item)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001188{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001189 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1190 struct se_ml_stat_grps, scsi_att_intr_port_group);
1191 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1192}
1193
1194static ssize_t target_stat_iport_inst_show(struct config_item *item,
1195 char *page)
1196{
1197 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001198 struct se_node_acl *nacl = lacl->se_lun_nacl;
1199 struct se_dev_entry *deve;
1200 struct se_portal_group *tpg;
1201 ssize_t ret;
1202
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001203 rcu_read_lock();
1204 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1205 if (!deve) {
1206 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001207 return -ENODEV;
1208 }
1209 tpg = nacl->se_tpg;
1210 /* scsiInstIndex */
1211 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +00001212 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001213 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001214 return ret;
1215}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001216
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001217static ssize_t target_stat_iport_dev_show(struct config_item *item,
1218 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001219{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001220 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001221 struct se_node_acl *nacl = lacl->se_lun_nacl;
1222 struct se_dev_entry *deve;
1223 struct se_lun *lun;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001224 ssize_t ret;
1225
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001226 rcu_read_lock();
1227 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1228 if (!deve) {
1229 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001230 return -ENODEV;
1231 }
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001232 lun = rcu_dereference(deve->se_lun);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001233 /* scsiDeviceIndex */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001234 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1235 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001236 return ret;
1237}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001238
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001239static ssize_t target_stat_iport_port_show(struct config_item *item,
1240 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001241{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001242 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001243 struct se_node_acl *nacl = lacl->se_lun_nacl;
1244 struct se_dev_entry *deve;
1245 struct se_portal_group *tpg;
1246 ssize_t ret;
1247
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001248 rcu_read_lock();
1249 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1250 if (!deve) {
1251 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001252 return -ENODEV;
1253 }
1254 tpg = nacl->se_tpg;
1255 /* scsiPortIndex */
Andy Grovere3d6f902011-07-19 08:55:10 +00001256 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001257 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001258 return ret;
1259}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001260
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001261static ssize_t target_stat_iport_indx_show(struct config_item *item,
1262 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001263{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001264 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001265 struct se_node_acl *nacl = lacl->se_lun_nacl;
1266 struct se_session *se_sess;
1267 struct se_portal_group *tpg;
1268 ssize_t ret;
1269
1270 spin_lock_irq(&nacl->nacl_sess_lock);
1271 se_sess = nacl->nacl_sess;
1272 if (!se_sess) {
1273 spin_unlock_irq(&nacl->nacl_sess_lock);
1274 return -ENODEV;
1275 }
1276
1277 tpg = nacl->se_tpg;
1278 /* scsiAttIntrPortIndex */
1279 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +00001280 tpg->se_tpg_tfo->sess_get_index(se_sess));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001281 spin_unlock_irq(&nacl->nacl_sess_lock);
1282 return ret;
1283}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001284
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001285static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item,
1286 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001287{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001288 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001289 struct se_node_acl *nacl = lacl->se_lun_nacl;
1290 struct se_dev_entry *deve;
1291 ssize_t ret;
1292
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001293 rcu_read_lock();
1294 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1295 if (!deve) {
1296 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001297 return -ENODEV;
1298 }
1299 /* scsiAttIntrPortAuthIntrIdx */
1300 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001301 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001302 return ret;
1303}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001304
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001305static ssize_t target_stat_iport_port_ident_show(struct config_item *item,
1306 char *page)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001307{
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001308 struct se_lun_acl *lacl = iport_to_lacl(item);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001309 struct se_node_acl *nacl = lacl->se_lun_nacl;
1310 struct se_session *se_sess;
1311 struct se_portal_group *tpg;
1312 ssize_t ret;
1313 unsigned char buf[64];
1314
1315 spin_lock_irq(&nacl->nacl_sess_lock);
1316 se_sess = nacl->nacl_sess;
1317 if (!se_sess) {
1318 spin_unlock_irq(&nacl->nacl_sess_lock);
1319 return -ENODEV;
1320 }
1321
1322 tpg = nacl->se_tpg;
1323 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1324 memset(buf, 0, 64);
Andy Grovere3d6f902011-07-19 08:55:10 +00001325 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
Jörn Engel8359cf42011-11-24 02:05:51 +01001326 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001327
1328 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1329 spin_unlock_irq(&nacl->nacl_sess_lock);
1330 return ret;
1331}
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001332
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001333CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1334CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1335CONFIGFS_ATTR_RO(target_stat_iport_, port);
1336CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1337CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1338CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001339
1340static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
Christoph Hellwig2eafd722015-10-03 15:32:55 +02001341 &target_stat_iport_attr_inst,
1342 &target_stat_iport_attr_dev,
1343 &target_stat_iport_attr_port,
1344 &target_stat_iport_attr_indx,
1345 &target_stat_iport_attr_port_auth_indx,
1346 &target_stat_iport_attr_port_ident,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001347 NULL,
1348};
1349
Bhumika Goyalece550b2017-10-16 17:18:42 +02001350static const struct config_item_type target_stat_scsi_att_intr_port_cit = {
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001351 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1352 .ct_owner = THIS_MODULE,
1353};
1354
1355/*
1356 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1357 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1358 */
1359void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1360{
Andy Grovere3d6f902011-07-19 08:55:10 +00001361 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001362 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +01001363 configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group,
1364 &lacl->ml_stat_grps.stat_group);
1365
Andy Grovere3d6f902011-07-19 08:55:10 +00001366 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001367 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
Christoph Hellwig1ae16022016-02-26 11:02:14 +01001368 configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1369 &lacl->ml_stat_grps.stat_group);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001370}