blob: 20ed5d2e151a6f50211273967e2cc107ba2b5bce [file] [log] [blame]
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001/*******************************************************************************
2 * Filename: target_core_stat.c
3 *
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07004 * Modern ConfigFS group context specific statistics based on original
5 * target_core_mib.c code
6 *
Nicholas Bellinger4c762512013-09-05 15:29:12 -07007 * (c) Copyright 2006-2013 Datera, Inc.
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07008 *
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>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070032#include <linux/utsname.h>
33#include <linux/proc_fs.h>
34#include <linux/seq_file.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070035#include <linux/configfs.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070036
37#include <target/target_core_base.h>
Christoph Hellwigc4795fb2011-11-16 09:46:48 -050038#include <target/target_core_backend.h>
39#include <target/target_core_fabric.h>
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070040#include <target/configfs_macros.h>
41
Christoph Hellwige26d99a2011-11-14 12:30:30 -050042#include "target_core_internal.h"
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070043
44#ifndef INITIAL_JIFFIES
45#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
46#endif
47
48#define NONE "None"
49#define ISPRINT(a) ((a >= ' ') && (a <= '~'))
50
51#define SCSI_LU_INDEX 1
52#define LU_COUNT 1
53
54/*
55 * SCSI Device Table
56 */
57
58CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
59#define DEV_STAT_SCSI_DEV_ATTR(_name, _mode) \
60static struct target_stat_scsi_dev_attribute \
61 target_stat_scsi_dev_##_name = \
62 __CONFIGFS_EATTR(_name, _mode, \
63 target_stat_scsi_dev_show_attr_##_name, \
64 target_stat_scsi_dev_store_attr_##_name);
65
66#define DEV_STAT_SCSI_DEV_ATTR_RO(_name) \
67static struct target_stat_scsi_dev_attribute \
68 target_stat_scsi_dev_##_name = \
69 __CONFIGFS_EATTR_RO(_name, \
70 target_stat_scsi_dev_show_attr_##_name);
71
72static ssize_t target_stat_scsi_dev_show_attr_inst(
73 struct se_dev_stat_grps *sgrps, char *page)
74{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -040075 struct se_device *dev =
76 container_of(sgrps, struct se_device, dev_stat_grps);
77 struct se_hba *hba = dev->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070078
79 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
80}
81DEV_STAT_SCSI_DEV_ATTR_RO(inst);
82
83static ssize_t target_stat_scsi_dev_show_attr_indx(
84 struct se_dev_stat_grps *sgrps, char *page)
85{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -040086 struct se_device *dev =
87 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070088
89 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
90}
91DEV_STAT_SCSI_DEV_ATTR_RO(indx);
92
93static ssize_t target_stat_scsi_dev_show_attr_role(
94 struct se_dev_stat_grps *sgrps, char *page)
95{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -070096 return snprintf(page, PAGE_SIZE, "Target\n");
97}
98DEV_STAT_SCSI_DEV_ATTR_RO(role);
99
100static ssize_t target_stat_scsi_dev_show_attr_ports(
101 struct se_dev_stat_grps *sgrps, char *page)
102{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400103 struct se_device *dev =
104 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700105
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700106 return snprintf(page, PAGE_SIZE, "%u\n", dev->export_count);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700107}
108DEV_STAT_SCSI_DEV_ATTR_RO(ports);
109
110CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
111
112static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
113 &target_stat_scsi_dev_inst.attr,
114 &target_stat_scsi_dev_indx.attr,
115 &target_stat_scsi_dev_role.attr,
116 &target_stat_scsi_dev_ports.attr,
117 NULL,
118};
119
120static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
121 .show_attribute = target_stat_scsi_dev_attr_show,
122 .store_attribute = target_stat_scsi_dev_attr_store,
123};
124
125static struct config_item_type target_stat_scsi_dev_cit = {
126 .ct_item_ops = &target_stat_scsi_dev_attrib_ops,
127 .ct_attrs = target_stat_scsi_dev_attrs,
128 .ct_owner = THIS_MODULE,
129};
130
131/*
132 * SCSI Target Device Table
133 */
134
135CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
136#define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode) \
137static struct target_stat_scsi_tgt_dev_attribute \
138 target_stat_scsi_tgt_dev_##_name = \
139 __CONFIGFS_EATTR(_name, _mode, \
140 target_stat_scsi_tgt_dev_show_attr_##_name, \
141 target_stat_scsi_tgt_dev_store_attr_##_name);
142
143#define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name) \
144static struct target_stat_scsi_tgt_dev_attribute \
145 target_stat_scsi_tgt_dev_##_name = \
146 __CONFIGFS_EATTR_RO(_name, \
147 target_stat_scsi_tgt_dev_show_attr_##_name);
148
149static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
150 struct se_dev_stat_grps *sgrps, char *page)
151{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400152 struct se_device *dev =
153 container_of(sgrps, struct se_device, dev_stat_grps);
154 struct se_hba *hba = dev->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700155
156 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
157}
158DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
159
160static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
161 struct se_dev_stat_grps *sgrps, char *page)
162{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400163 struct se_device *dev =
164 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700165
166 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
167}
168DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
169
170static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
171 struct se_dev_stat_grps *sgrps, char *page)
172{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700173 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
174}
175DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
176
177static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
178 struct se_dev_stat_grps *sgrps, char *page)
179{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400180 struct se_device *dev =
181 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700182
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400183 if (dev->export_count)
184 return snprintf(page, PAGE_SIZE, "activated");
185 else
186 return snprintf(page, PAGE_SIZE, "deactivated");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700187}
188DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
189
190static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
191 struct se_dev_stat_grps *sgrps, char *page)
192{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400193 struct se_device *dev =
194 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700195 int non_accessible_lus;
196
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400197 if (dev->export_count)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700198 non_accessible_lus = 0;
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400199 else
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700200 non_accessible_lus = 1;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700201
202 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
203}
204DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
205
206static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
207 struct se_dev_stat_grps *sgrps, char *page)
208{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400209 struct se_device *dev =
210 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700211
Nicholas Bellingeree480682013-11-13 18:34:55 -0800212 return snprintf(page, PAGE_SIZE, "%lu\n",
213 atomic_long_read(&dev->num_resets));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700214}
215DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
216
217
218CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
219
220static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
221 &target_stat_scsi_tgt_dev_inst.attr,
222 &target_stat_scsi_tgt_dev_indx.attr,
223 &target_stat_scsi_tgt_dev_num_lus.attr,
224 &target_stat_scsi_tgt_dev_status.attr,
225 &target_stat_scsi_tgt_dev_non_access_lus.attr,
226 &target_stat_scsi_tgt_dev_resets.attr,
227 NULL,
228};
229
230static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
231 .show_attribute = target_stat_scsi_tgt_dev_attr_show,
232 .store_attribute = target_stat_scsi_tgt_dev_attr_store,
233};
234
235static struct config_item_type target_stat_scsi_tgt_dev_cit = {
236 .ct_item_ops = &target_stat_scsi_tgt_dev_attrib_ops,
237 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
238 .ct_owner = THIS_MODULE,
239};
240
241/*
242 * SCSI Logical Unit Table
243 */
244
245CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
246#define DEV_STAT_SCSI_LU_ATTR(_name, _mode) \
247static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
248 __CONFIGFS_EATTR(_name, _mode, \
249 target_stat_scsi_lu_show_attr_##_name, \
250 target_stat_scsi_lu_store_attr_##_name);
251
252#define DEV_STAT_SCSI_LU_ATTR_RO(_name) \
253static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
254 __CONFIGFS_EATTR_RO(_name, \
255 target_stat_scsi_lu_show_attr_##_name);
256
257static ssize_t target_stat_scsi_lu_show_attr_inst(
258 struct se_dev_stat_grps *sgrps, char *page)
259{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400260 struct se_device *dev =
261 container_of(sgrps, struct se_device, dev_stat_grps);
262 struct se_hba *hba = dev->se_hba;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700263
264 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
265}
266DEV_STAT_SCSI_LU_ATTR_RO(inst);
267
268static ssize_t target_stat_scsi_lu_show_attr_dev(
269 struct se_dev_stat_grps *sgrps, char *page)
270{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400271 struct se_device *dev =
272 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700273
274 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
275}
276DEV_STAT_SCSI_LU_ATTR_RO(dev);
277
278static ssize_t target_stat_scsi_lu_show_attr_indx(
279 struct se_dev_stat_grps *sgrps, char *page)
280{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700281 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
282}
283DEV_STAT_SCSI_LU_ATTR_RO(indx);
284
285static ssize_t target_stat_scsi_lu_show_attr_lun(
286 struct se_dev_stat_grps *sgrps, char *page)
287{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700288 /* FIXME: scsiLuDefaultLun */
289 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
290}
291DEV_STAT_SCSI_LU_ATTR_RO(lun);
292
293static ssize_t target_stat_scsi_lu_show_attr_lu_name(
294 struct se_dev_stat_grps *sgrps, char *page)
295{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400296 struct se_device *dev =
297 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700298
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700299 /* scsiLuWwnName */
300 return snprintf(page, PAGE_SIZE, "%s\n",
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400301 (strlen(dev->t10_wwn.unit_serial)) ?
302 dev->t10_wwn.unit_serial : "None");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700303}
304DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
305
306static ssize_t target_stat_scsi_lu_show_attr_vend(
307 struct se_dev_stat_grps *sgrps, char *page)
308{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400309 struct se_device *dev =
310 container_of(sgrps, struct se_device, dev_stat_grps);
Andy Grovere3d6f902011-07-19 08:55:10 +0000311 int i;
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400312 char str[sizeof(dev->t10_wwn.vendor)+1];
Andy Grovere3d6f902011-07-19 08:55:10 +0000313
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700314 /* scsiLuVendorId */
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400315 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
316 str[i] = ISPRINT(dev->t10_wwn.vendor[i]) ?
317 dev->t10_wwn.vendor[i] : ' ';
Andy Grovere3d6f902011-07-19 08:55:10 +0000318 str[i] = '\0';
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700319 return snprintf(page, PAGE_SIZE, "%s\n", str);
320}
321DEV_STAT_SCSI_LU_ATTR_RO(vend);
322
323static ssize_t target_stat_scsi_lu_show_attr_prod(
324 struct se_dev_stat_grps *sgrps, char *page)
325{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400326 struct se_device *dev =
327 container_of(sgrps, struct se_device, dev_stat_grps);
Andy Grovere3d6f902011-07-19 08:55:10 +0000328 int i;
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400329 char str[sizeof(dev->t10_wwn.model)+1];
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700330
331 /* scsiLuProductId */
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400332 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
333 str[i] = ISPRINT(dev->t10_wwn.model[i]) ?
334 dev->t10_wwn.model[i] : ' ';
Andy Grovere3d6f902011-07-19 08:55:10 +0000335 str[i] = '\0';
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700336 return snprintf(page, PAGE_SIZE, "%s\n", str);
337}
338DEV_STAT_SCSI_LU_ATTR_RO(prod);
339
340static ssize_t target_stat_scsi_lu_show_attr_rev(
341 struct se_dev_stat_grps *sgrps, char *page)
342{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400343 struct se_device *dev =
344 container_of(sgrps, struct se_device, dev_stat_grps);
Andy Grovere3d6f902011-07-19 08:55:10 +0000345 int i;
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400346 char str[sizeof(dev->t10_wwn.revision)+1];
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700347
348 /* scsiLuRevisionId */
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400349 for (i = 0; i < sizeof(dev->t10_wwn.revision); i++)
350 str[i] = ISPRINT(dev->t10_wwn.revision[i]) ?
351 dev->t10_wwn.revision[i] : ' ';
Andy Grovere3d6f902011-07-19 08:55:10 +0000352 str[i] = '\0';
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700353 return snprintf(page, PAGE_SIZE, "%s\n", str);
354}
355DEV_STAT_SCSI_LU_ATTR_RO(rev);
356
357static ssize_t target_stat_scsi_lu_show_attr_dev_type(
358 struct se_dev_stat_grps *sgrps, char *page)
359{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400360 struct se_device *dev =
361 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700362
363 /* scsiLuPeripheralType */
364 return snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +0000365 dev->transport->get_device_type(dev));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700366}
367DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
368
369static ssize_t target_stat_scsi_lu_show_attr_status(
370 struct se_dev_stat_grps *sgrps, char *page)
371{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400372 struct se_device *dev =
373 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700374
375 /* scsiLuStatus */
376 return snprintf(page, PAGE_SIZE, "%s\n",
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400377 (dev->export_count) ? "available" : "notavailable");
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700378}
379DEV_STAT_SCSI_LU_ATTR_RO(status);
380
381static ssize_t target_stat_scsi_lu_show_attr_state_bit(
382 struct se_dev_stat_grps *sgrps, char *page)
383{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700384 /* scsiLuState */
385 return snprintf(page, PAGE_SIZE, "exposed\n");
386}
387DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
388
389static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
390 struct se_dev_stat_grps *sgrps, char *page)
391{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400392 struct se_device *dev =
393 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700394
395 /* scsiLuNumCommands */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800396 return snprintf(page, PAGE_SIZE, "%lu\n",
397 atomic_long_read(&dev->num_cmds));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700398}
399DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
400
401static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
402 struct se_dev_stat_grps *sgrps, char *page)
403{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400404 struct se_device *dev =
405 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700406
407 /* scsiLuReadMegaBytes */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800408 return snprintf(page, PAGE_SIZE, "%lu\n",
409 atomic_long_read(&dev->read_bytes) >> 20);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700410}
411DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
412
413static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
414 struct se_dev_stat_grps *sgrps, char *page)
415{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400416 struct se_device *dev =
417 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700418
419 /* scsiLuWrittenMegaBytes */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800420 return snprintf(page, PAGE_SIZE, "%lu\n",
421 atomic_long_read(&dev->write_bytes) >> 20);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700422}
423DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
424
425static ssize_t target_stat_scsi_lu_show_attr_resets(
426 struct se_dev_stat_grps *sgrps, char *page)
427{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400428 struct se_device *dev =
429 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700430
431 /* scsiLuInResets */
Nicholas Bellingeree480682013-11-13 18:34:55 -0800432 return snprintf(page, PAGE_SIZE, "%lu\n", atomic_long_read(&dev->num_resets));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700433}
434DEV_STAT_SCSI_LU_ATTR_RO(resets);
435
436static ssize_t target_stat_scsi_lu_show_attr_full_stat(
437 struct se_dev_stat_grps *sgrps, char *page)
438{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700439 /* FIXME: scsiLuOutTaskSetFullStatus */
440 return snprintf(page, PAGE_SIZE, "%u\n", 0);
441}
442DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
443
444static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
445 struct se_dev_stat_grps *sgrps, char *page)
446{
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700447 /* FIXME: scsiLuHSInCommands */
448 return snprintf(page, PAGE_SIZE, "%u\n", 0);
449}
450DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
451
452static ssize_t target_stat_scsi_lu_show_attr_creation_time(
453 struct se_dev_stat_grps *sgrps, char *page)
454{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400455 struct se_device *dev =
456 container_of(sgrps, struct se_device, dev_stat_grps);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700457
458 /* scsiLuCreationTime */
459 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
460 INITIAL_JIFFIES) * 100 / HZ));
461}
462DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
463
464CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
465
466static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
467 &target_stat_scsi_lu_inst.attr,
468 &target_stat_scsi_lu_dev.attr,
469 &target_stat_scsi_lu_indx.attr,
470 &target_stat_scsi_lu_lun.attr,
471 &target_stat_scsi_lu_lu_name.attr,
472 &target_stat_scsi_lu_vend.attr,
473 &target_stat_scsi_lu_prod.attr,
474 &target_stat_scsi_lu_rev.attr,
475 &target_stat_scsi_lu_dev_type.attr,
476 &target_stat_scsi_lu_status.attr,
477 &target_stat_scsi_lu_state_bit.attr,
478 &target_stat_scsi_lu_num_cmds.attr,
479 &target_stat_scsi_lu_read_mbytes.attr,
480 &target_stat_scsi_lu_write_mbytes.attr,
481 &target_stat_scsi_lu_resets.attr,
482 &target_stat_scsi_lu_full_stat.attr,
483 &target_stat_scsi_lu_hs_num_cmds.attr,
484 &target_stat_scsi_lu_creation_time.attr,
485 NULL,
486};
487
488static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
489 .show_attribute = target_stat_scsi_lu_attr_show,
490 .store_attribute = target_stat_scsi_lu_attr_store,
491};
492
493static struct config_item_type target_stat_scsi_lu_cit = {
494 .ct_item_ops = &target_stat_scsi_lu_attrib_ops,
495 .ct_attrs = target_stat_scsi_lu_attrs,
496 .ct_owner = THIS_MODULE,
497};
498
499/*
500 * Called from target_core_configfs.c:target_core_make_subdev() to setup
501 * the target statistics groups + configfs CITs located in target_core_stat.c
502 */
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400503void target_stat_setup_dev_default_groups(struct se_device *dev)
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700504{
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400505 struct config_group *dev_stat_grp = &dev->dev_stat_grps.stat_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700506
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400507 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700508 "scsi_dev", &target_stat_scsi_dev_cit);
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400509 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700510 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400511 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700512 "scsi_lu", &target_stat_scsi_lu_cit);
513
Christoph Hellwig0fd97cc2012-10-08 00:03:19 -0400514 dev_stat_grp->default_groups[0] = &dev->dev_stat_grps.scsi_dev_group;
515 dev_stat_grp->default_groups[1] = &dev->dev_stat_grps.scsi_tgt_dev_group;
516 dev_stat_grp->default_groups[2] = &dev->dev_stat_grps.scsi_lu_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700517 dev_stat_grp->default_groups[3] = NULL;
518}
519
520/*
521 * SCSI Port Table
522 */
523
524CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
525#define DEV_STAT_SCSI_PORT_ATTR(_name, _mode) \
526static struct target_stat_scsi_port_attribute \
527 target_stat_scsi_port_##_name = \
528 __CONFIGFS_EATTR(_name, _mode, \
529 target_stat_scsi_port_show_attr_##_name, \
530 target_stat_scsi_port_store_attr_##_name);
531
532#define DEV_STAT_SCSI_PORT_ATTR_RO(_name) \
533static struct target_stat_scsi_port_attribute \
534 target_stat_scsi_port_##_name = \
535 __CONFIGFS_EATTR_RO(_name, \
536 target_stat_scsi_port_show_attr_##_name);
537
538static ssize_t target_stat_scsi_port_show_attr_inst(
539 struct se_port_stat_grps *pgrps, char *page)
540{
541 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700542 struct se_device *dev;
543 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700544
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700545 rcu_read_lock();
546 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700547 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700548 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
549 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700550 return ret;
551}
552DEV_STAT_SCSI_PORT_ATTR_RO(inst);
553
554static ssize_t target_stat_scsi_port_show_attr_dev(
555 struct se_port_stat_grps *pgrps, char *page)
556{
557 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700558 struct se_device *dev;
559 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700560
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700561 rcu_read_lock();
562 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700563 if (dev)
564 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700565 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700566 return ret;
567}
568DEV_STAT_SCSI_PORT_ATTR_RO(dev);
569
570static ssize_t target_stat_scsi_port_show_attr_indx(
571 struct se_port_stat_grps *pgrps, char *page)
572{
573 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700574 struct se_device *dev;
575 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700576
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700577 rcu_read_lock();
578 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700579 if (dev)
580 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700581 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700582 return ret;
583}
584DEV_STAT_SCSI_PORT_ATTR_RO(indx);
585
586static ssize_t target_stat_scsi_port_show_attr_role(
587 struct se_port_stat_grps *pgrps, char *page)
588{
589 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700590 struct se_device *dev;
591 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700592
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700593 rcu_read_lock();
594 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700595 if (dev)
596 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700597 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700598 return ret;
599}
600DEV_STAT_SCSI_PORT_ATTR_RO(role);
601
602static ssize_t target_stat_scsi_port_show_attr_busy_count(
603 struct se_port_stat_grps *pgrps, char *page)
604{
605 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700606 struct se_device *dev;
607 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700608
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700609 rcu_read_lock();
610 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700611 if (dev) {
612 /* FIXME: scsiPortBusyStatuses */
613 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700614 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700615 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700616 return ret;
617}
618DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
619
620CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
621
622static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
623 &target_stat_scsi_port_inst.attr,
624 &target_stat_scsi_port_dev.attr,
625 &target_stat_scsi_port_indx.attr,
626 &target_stat_scsi_port_role.attr,
627 &target_stat_scsi_port_busy_count.attr,
628 NULL,
629};
630
631static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
632 .show_attribute = target_stat_scsi_port_attr_show,
633 .store_attribute = target_stat_scsi_port_attr_store,
634};
635
636static struct config_item_type target_stat_scsi_port_cit = {
637 .ct_item_ops = &target_stat_scsi_port_attrib_ops,
638 .ct_attrs = target_stat_scsi_port_attrs,
639 .ct_owner = THIS_MODULE,
640};
641
642/*
643 * SCSI Target Port Table
644 */
645CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
646#define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode) \
647static struct target_stat_scsi_tgt_port_attribute \
648 target_stat_scsi_tgt_port_##_name = \
649 __CONFIGFS_EATTR(_name, _mode, \
650 target_stat_scsi_tgt_port_show_attr_##_name, \
651 target_stat_scsi_tgt_port_store_attr_##_name);
652
653#define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name) \
654static struct target_stat_scsi_tgt_port_attribute \
655 target_stat_scsi_tgt_port_##_name = \
656 __CONFIGFS_EATTR_RO(_name, \
657 target_stat_scsi_tgt_port_show_attr_##_name);
658
659static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
660 struct se_port_stat_grps *pgrps, char *page)
661{
662 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700663 struct se_device *dev;
664 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700665
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700666 rcu_read_lock();
667 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700668 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700669 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
670 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700671 return ret;
672}
673DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
674
675static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
676 struct se_port_stat_grps *pgrps, char *page)
677{
678 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700679 struct se_device *dev;
680 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700681
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700682 rcu_read_lock();
683 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700684 if (dev)
685 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700686 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700687 return ret;
688}
689DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
690
691static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
692 struct se_port_stat_grps *pgrps, char *page)
693{
694 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700695 struct se_device *dev;
696 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700697
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700698 rcu_read_lock();
699 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700700 if (dev)
701 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700702 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700703 return ret;
704}
705DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
706
707static ssize_t target_stat_scsi_tgt_port_show_attr_name(
708 struct se_port_stat_grps *pgrps, char *page)
709{
710 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700711 struct se_portal_group *tpg = lun->lun_tpg;
712 struct se_device *dev;
713 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700714
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700715 rcu_read_lock();
716 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700717 if (dev)
718 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
719 tpg->se_tpg_tfo->get_fabric_name(),
720 lun->lun_rtpi);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700721 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700722 return ret;
723}
724DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
725
726static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
727 struct se_port_stat_grps *pgrps, char *page)
728{
729 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700730 struct se_portal_group *tpg = lun->lun_tpg;
731 struct se_device *dev;
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 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
738 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
739 tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700740 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700741 return ret;
742}
743DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
744
745static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
746 struct se_port_stat_grps *pgrps, char *page)
747{
748 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700749 struct se_device *dev;
750 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700751
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700752 rcu_read_lock();
753 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700754 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700755 ret = snprintf(page, PAGE_SIZE, "%lu\n",
756 atomic_long_read(&lun->lun_stats.cmd_pdus));
757 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700758 return ret;
759}
760DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
761
762static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
763 struct se_port_stat_grps *pgrps, char *page)
764{
765 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700766 struct se_device *dev;
767 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700768
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700769 rcu_read_lock();
770 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700771 if (dev)
772 ret = snprintf(page, PAGE_SIZE, "%u\n",
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700773 (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
774 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700775 return ret;
776}
777DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
778
779static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
780 struct se_port_stat_grps *pgrps, char *page)
781{
782 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700783 struct se_device *dev;
784 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700785
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700786 rcu_read_lock();
787 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700788 if (dev)
789 ret = snprintf(page, PAGE_SIZE, "%u\n",
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700790 (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
791 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700792 return ret;
793}
794DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
795
796static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
797 struct se_port_stat_grps *pgrps, char *page)
798{
799 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700800 struct se_device *dev;
801 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700802
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700803 rcu_read_lock();
804 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700805 if (dev) {
806 /* FIXME: scsiTgtPortHsInCommands */
807 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700808 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700809 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700810 return ret;
811}
812DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
813
814CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
815 scsi_tgt_port_group);
816
817static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
818 &target_stat_scsi_tgt_port_inst.attr,
819 &target_stat_scsi_tgt_port_dev.attr,
820 &target_stat_scsi_tgt_port_indx.attr,
821 &target_stat_scsi_tgt_port_name.attr,
822 &target_stat_scsi_tgt_port_port_index.attr,
823 &target_stat_scsi_tgt_port_in_cmds.attr,
824 &target_stat_scsi_tgt_port_write_mbytes.attr,
825 &target_stat_scsi_tgt_port_read_mbytes.attr,
826 &target_stat_scsi_tgt_port_hs_in_cmds.attr,
827 NULL,
828};
829
830static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
831 .show_attribute = target_stat_scsi_tgt_port_attr_show,
832 .store_attribute = target_stat_scsi_tgt_port_attr_store,
833};
834
835static struct config_item_type target_stat_scsi_tgt_port_cit = {
836 .ct_item_ops = &target_stat_scsi_tgt_port_attrib_ops,
837 .ct_attrs = target_stat_scsi_tgt_port_attrs,
838 .ct_owner = THIS_MODULE,
839};
840
841/*
842 * SCSI Transport Table
843o */
844
845CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
846#define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode) \
847static struct target_stat_scsi_transport_attribute \
848 target_stat_scsi_transport_##_name = \
849 __CONFIGFS_EATTR(_name, _mode, \
850 target_stat_scsi_transport_show_attr_##_name, \
851 target_stat_scsi_transport_store_attr_##_name);
852
853#define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name) \
854static struct target_stat_scsi_transport_attribute \
855 target_stat_scsi_transport_##_name = \
856 __CONFIGFS_EATTR_RO(_name, \
857 target_stat_scsi_transport_show_attr_##_name);
858
859static ssize_t target_stat_scsi_transport_show_attr_inst(
860 struct se_port_stat_grps *pgrps, char *page)
861{
862 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700863 struct se_device *dev;
864 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700865
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700866 rcu_read_lock();
867 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700868 if (dev)
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700869 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
870 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700871 return ret;
872}
873DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
874
875static ssize_t target_stat_scsi_transport_show_attr_device(
876 struct se_port_stat_grps *pgrps, char *page)
877{
878 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700879 struct se_device *dev;
880 struct se_portal_group *tpg = lun->lun_tpg;
881 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700882
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700883 rcu_read_lock();
884 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700885 if (dev) {
886 /* scsiTransportType */
887 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
888 tpg->se_tpg_tfo->get_fabric_name());
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700889 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700890 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700891 return ret;
892}
893DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
894
895static ssize_t target_stat_scsi_transport_show_attr_indx(
896 struct se_port_stat_grps *pgrps, char *page)
897{
898 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700899 struct se_device *dev;
900 struct se_portal_group *tpg = lun->lun_tpg;
901 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700902
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700903 rcu_read_lock();
904 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700905 if (dev)
906 ret = snprintf(page, PAGE_SIZE, "%u\n",
907 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700908 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700909 return ret;
910}
911DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
912
913static ssize_t target_stat_scsi_transport_show_attr_dev_name(
914 struct se_port_stat_grps *pgrps, char *page)
915{
916 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700917 struct se_device *dev;
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700918 struct se_portal_group *tpg = lun->lun_tpg;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700919 struct t10_wwn *wwn;
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700920 ssize_t ret = -ENODEV;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700921
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700922 rcu_read_lock();
923 dev = rcu_dereference(lun->lun_se_dev);
Christoph Hellwigadf653f2015-05-25 21:33:08 -0700924 if (dev) {
925 wwn = &dev->t10_wwn;
926 /* scsiTransportDevName */
927 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
928 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
929 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
930 wwn->vendor);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700931 }
Nicholas Bellinger4cc987e2015-05-19 00:03:07 -0700932 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700933 return ret;
934}
935DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
936
937CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
938 scsi_transport_group);
939
940static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
941 &target_stat_scsi_transport_inst.attr,
942 &target_stat_scsi_transport_device.attr,
943 &target_stat_scsi_transport_indx.attr,
944 &target_stat_scsi_transport_dev_name.attr,
945 NULL,
946};
947
948static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
949 .show_attribute = target_stat_scsi_transport_attr_show,
950 .store_attribute = target_stat_scsi_transport_attr_store,
951};
952
953static struct config_item_type target_stat_scsi_transport_cit = {
954 .ct_item_ops = &target_stat_scsi_transport_attrib_ops,
955 .ct_attrs = target_stat_scsi_transport_attrs,
956 .ct_owner = THIS_MODULE,
957};
958
959/*
960 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
961 * the target port statistics groups + configfs CITs located in target_core_stat.c
962 */
963void target_stat_setup_port_default_groups(struct se_lun *lun)
964{
Andy Grovere3d6f902011-07-19 08:55:10 +0000965 struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700966
Andy Grovere3d6f902011-07-19 08:55:10 +0000967 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700968 "scsi_port", &target_stat_scsi_port_cit);
Andy Grovere3d6f902011-07-19 08:55:10 +0000969 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700970 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
Andy Grovere3d6f902011-07-19 08:55:10 +0000971 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700972 "scsi_transport", &target_stat_scsi_transport_cit);
973
Andy Grovere3d6f902011-07-19 08:55:10 +0000974 port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
975 port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
976 port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -0700977 port_stat_grp->default_groups[3] = NULL;
978}
979
980/*
981 * SCSI Authorized Initiator Table
982 */
983
984CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
985#define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode) \
986static struct target_stat_scsi_auth_intr_attribute \
987 target_stat_scsi_auth_intr_##_name = \
988 __CONFIGFS_EATTR(_name, _mode, \
989 target_stat_scsi_auth_intr_show_attr_##_name, \
990 target_stat_scsi_auth_intr_store_attr_##_name);
991
992#define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name) \
993static struct target_stat_scsi_auth_intr_attribute \
994 target_stat_scsi_auth_intr_##_name = \
995 __CONFIGFS_EATTR_RO(_name, \
996 target_stat_scsi_auth_intr_show_attr_##_name);
997
998static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
999 struct se_ml_stat_grps *lgrps, char *page)
1000{
1001 struct se_lun_acl *lacl = container_of(lgrps,
1002 struct se_lun_acl, ml_stat_grps);
1003 struct se_node_acl *nacl = lacl->se_lun_nacl;
1004 struct se_dev_entry *deve;
1005 struct se_portal_group *tpg;
1006 ssize_t ret;
1007
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001008 rcu_read_lock();
1009 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1010 if (!deve) {
1011 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001012 return -ENODEV;
1013 }
1014 tpg = nacl->se_tpg;
1015 /* scsiInstIndex */
1016 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +00001017 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001018 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001019 return ret;
1020}
1021DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1022
1023static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1024 struct se_ml_stat_grps *lgrps, char *page)
1025{
1026 struct se_lun_acl *lacl = container_of(lgrps,
1027 struct se_lun_acl, ml_stat_grps);
1028 struct se_node_acl *nacl = lacl->se_lun_nacl;
1029 struct se_dev_entry *deve;
1030 struct se_lun *lun;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001031 ssize_t ret;
1032
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001033 rcu_read_lock();
1034 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1035 if (!deve) {
1036 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001037 return -ENODEV;
1038 }
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001039 lun = rcu_dereference(deve->se_lun);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001040 /* scsiDeviceIndex */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001041 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1042 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001043 return ret;
1044}
1045DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1046
1047static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1048 struct se_ml_stat_grps *lgrps, char *page)
1049{
1050 struct se_lun_acl *lacl = container_of(lgrps,
1051 struct se_lun_acl, ml_stat_grps);
1052 struct se_node_acl *nacl = lacl->se_lun_nacl;
1053 struct se_dev_entry *deve;
1054 struct se_portal_group *tpg;
1055 ssize_t ret;
1056
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001057 rcu_read_lock();
1058 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1059 if (!deve) {
1060 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001061 return -ENODEV;
1062 }
1063 tpg = nacl->se_tpg;
1064 /* scsiAuthIntrTgtPortIndex */
Andy Grovere3d6f902011-07-19 08:55:10 +00001065 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001066 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001067 return ret;
1068}
1069DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1070
1071static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1072 struct se_ml_stat_grps *lgrps, char *page)
1073{
1074 struct se_lun_acl *lacl = container_of(lgrps,
1075 struct se_lun_acl, ml_stat_grps);
1076 struct se_node_acl *nacl = lacl->se_lun_nacl;
1077 struct se_dev_entry *deve;
1078 ssize_t ret;
1079
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001080 rcu_read_lock();
1081 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1082 if (!deve) {
1083 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001084 return -ENODEV;
1085 }
1086 /* scsiAuthIntrIndex */
1087 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001088 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001089 return ret;
1090}
1091DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1092
1093static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1094 struct se_ml_stat_grps *lgrps, char *page)
1095{
1096 struct se_lun_acl *lacl = container_of(lgrps,
1097 struct se_lun_acl, ml_stat_grps);
1098 struct se_node_acl *nacl = lacl->se_lun_nacl;
1099 struct se_dev_entry *deve;
1100 ssize_t ret;
1101
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001102 rcu_read_lock();
1103 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1104 if (!deve) {
1105 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001106 return -ENODEV;
1107 }
1108 /* scsiAuthIntrDevOrPort */
1109 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001110 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001111 return ret;
1112}
1113DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1114
1115static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1116 struct se_ml_stat_grps *lgrps, char *page)
1117{
1118 struct se_lun_acl *lacl = container_of(lgrps,
1119 struct se_lun_acl, ml_stat_grps);
1120 struct se_node_acl *nacl = lacl->se_lun_nacl;
1121 struct se_dev_entry *deve;
1122 ssize_t ret;
1123
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001124 rcu_read_lock();
1125 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1126 if (!deve) {
1127 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001128 return -ENODEV;
1129 }
1130 /* scsiAuthIntrName */
1131 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001132 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001133 return ret;
1134}
1135DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1136
1137static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1138 struct se_ml_stat_grps *lgrps, char *page)
1139{
1140 struct se_lun_acl *lacl = container_of(lgrps,
1141 struct se_lun_acl, ml_stat_grps);
1142 struct se_node_acl *nacl = lacl->se_lun_nacl;
1143 struct se_dev_entry *deve;
1144 ssize_t ret;
1145
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001146 rcu_read_lock();
1147 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1148 if (!deve) {
1149 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001150 return -ENODEV;
1151 }
1152 /* FIXME: scsiAuthIntrLunMapIndex */
1153 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001154 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001155 return ret;
1156}
1157DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1158
1159static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1160 struct se_ml_stat_grps *lgrps, char *page)
1161{
1162 struct se_lun_acl *lacl = container_of(lgrps,
1163 struct se_lun_acl, ml_stat_grps);
1164 struct se_node_acl *nacl = lacl->se_lun_nacl;
1165 struct se_dev_entry *deve;
1166 ssize_t ret;
1167
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001168 rcu_read_lock();
1169 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1170 if (!deve) {
1171 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001172 return -ENODEV;
1173 }
1174 /* scsiAuthIntrAttachedTimes */
1175 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001176 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001177 return ret;
1178}
1179DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1180
1181static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1182 struct se_ml_stat_grps *lgrps, char *page)
1183{
1184 struct se_lun_acl *lacl = container_of(lgrps,
1185 struct se_lun_acl, ml_stat_grps);
1186 struct se_node_acl *nacl = lacl->se_lun_nacl;
1187 struct se_dev_entry *deve;
1188 ssize_t ret;
1189
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001190 rcu_read_lock();
1191 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1192 if (!deve) {
1193 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001194 return -ENODEV;
1195 }
1196 /* scsiAuthIntrOutCommands */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001197 ret = snprintf(page, PAGE_SIZE, "%lu\n",
1198 atomic_long_read(&deve->total_cmds));
1199 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001200 return ret;
1201}
1202DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1203
1204static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1205 struct se_ml_stat_grps *lgrps, char *page)
1206{
1207 struct se_lun_acl *lacl = container_of(lgrps,
1208 struct se_lun_acl, ml_stat_grps);
1209 struct se_node_acl *nacl = lacl->se_lun_nacl;
1210 struct se_dev_entry *deve;
1211 ssize_t ret;
1212
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001213 rcu_read_lock();
1214 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1215 if (!deve) {
1216 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001217 return -ENODEV;
1218 }
1219 /* scsiAuthIntrReadMegaBytes */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001220 ret = snprintf(page, PAGE_SIZE, "%u\n",
1221 (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1222 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001223 return ret;
1224}
1225DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1226
1227static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1228 struct se_ml_stat_grps *lgrps, char *page)
1229{
1230 struct se_lun_acl *lacl = container_of(lgrps,
1231 struct se_lun_acl, ml_stat_grps);
1232 struct se_node_acl *nacl = lacl->se_lun_nacl;
1233 struct se_dev_entry *deve;
1234 ssize_t ret;
1235
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001236 rcu_read_lock();
1237 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1238 if (!deve) {
1239 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001240 return -ENODEV;
1241 }
1242 /* scsiAuthIntrWrittenMegaBytes */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001243 ret = snprintf(page, PAGE_SIZE, "%u\n",
1244 (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1245 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001246 return ret;
1247}
1248DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1249
1250static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1251 struct se_ml_stat_grps *lgrps, char *page)
1252{
1253 struct se_lun_acl *lacl = container_of(lgrps,
1254 struct se_lun_acl, ml_stat_grps);
1255 struct se_node_acl *nacl = lacl->se_lun_nacl;
1256 struct se_dev_entry *deve;
1257 ssize_t ret;
1258
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001259 rcu_read_lock();
1260 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1261 if (!deve) {
1262 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001263 return -ENODEV;
1264 }
1265 /* FIXME: scsiAuthIntrHSOutCommands */
1266 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001267 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001268 return ret;
1269}
1270DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1271
1272static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1273 struct se_ml_stat_grps *lgrps, char *page)
1274{
1275 struct se_lun_acl *lacl = container_of(lgrps,
1276 struct se_lun_acl, ml_stat_grps);
1277 struct se_node_acl *nacl = lacl->se_lun_nacl;
1278 struct se_dev_entry *deve;
1279 ssize_t ret;
1280
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001281 rcu_read_lock();
1282 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1283 if (!deve) {
1284 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001285 return -ENODEV;
1286 }
1287 /* scsiAuthIntrLastCreation */
1288 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1289 INITIAL_JIFFIES) * 100 / HZ));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001290 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001291 return ret;
1292}
1293DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1294
1295static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1296 struct se_ml_stat_grps *lgrps, char *page)
1297{
1298 struct se_lun_acl *lacl = container_of(lgrps,
1299 struct se_lun_acl, ml_stat_grps);
1300 struct se_node_acl *nacl = lacl->se_lun_nacl;
1301 struct se_dev_entry *deve;
1302 ssize_t ret;
1303
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001304 rcu_read_lock();
1305 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1306 if (!deve) {
1307 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001308 return -ENODEV;
1309 }
1310 /* FIXME: scsiAuthIntrRowStatus */
1311 ret = snprintf(page, PAGE_SIZE, "Ready\n");
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001312 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001313 return ret;
1314}
1315DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1316
1317CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1318 scsi_auth_intr_group);
1319
1320static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1321 &target_stat_scsi_auth_intr_inst.attr,
1322 &target_stat_scsi_auth_intr_dev.attr,
1323 &target_stat_scsi_auth_intr_port.attr,
1324 &target_stat_scsi_auth_intr_indx.attr,
1325 &target_stat_scsi_auth_intr_dev_or_port.attr,
1326 &target_stat_scsi_auth_intr_intr_name.attr,
1327 &target_stat_scsi_auth_intr_map_indx.attr,
1328 &target_stat_scsi_auth_intr_att_count.attr,
1329 &target_stat_scsi_auth_intr_num_cmds.attr,
1330 &target_stat_scsi_auth_intr_read_mbytes.attr,
1331 &target_stat_scsi_auth_intr_write_mbytes.attr,
1332 &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1333 &target_stat_scsi_auth_intr_creation_time.attr,
1334 &target_stat_scsi_auth_intr_row_status.attr,
1335 NULL,
1336};
1337
1338static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1339 .show_attribute = target_stat_scsi_auth_intr_attr_show,
1340 .store_attribute = target_stat_scsi_auth_intr_attr_store,
1341};
1342
1343static struct config_item_type target_stat_scsi_auth_intr_cit = {
1344 .ct_item_ops = &target_stat_scsi_auth_intr_attrib_ops,
1345 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1346 .ct_owner = THIS_MODULE,
1347};
1348
1349/*
1350 * SCSI Attached Initiator Port Table
1351 */
1352
1353CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1354#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode) \
1355static struct target_stat_scsi_att_intr_port_attribute \
1356 target_stat_scsi_att_intr_port_##_name = \
1357 __CONFIGFS_EATTR(_name, _mode, \
1358 target_stat_scsi_att_intr_port_show_attr_##_name, \
1359 target_stat_scsi_att_intr_port_store_attr_##_name);
1360
1361#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name) \
1362static struct target_stat_scsi_att_intr_port_attribute \
1363 target_stat_scsi_att_intr_port_##_name = \
1364 __CONFIGFS_EATTR_RO(_name, \
1365 target_stat_scsi_att_intr_port_show_attr_##_name);
1366
1367static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1368 struct se_ml_stat_grps *lgrps, char *page)
1369{
1370 struct se_lun_acl *lacl = container_of(lgrps,
1371 struct se_lun_acl, ml_stat_grps);
1372 struct se_node_acl *nacl = lacl->se_lun_nacl;
1373 struct se_dev_entry *deve;
1374 struct se_portal_group *tpg;
1375 ssize_t ret;
1376
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001377 rcu_read_lock();
1378 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1379 if (!deve) {
1380 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001381 return -ENODEV;
1382 }
1383 tpg = nacl->se_tpg;
1384 /* scsiInstIndex */
1385 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +00001386 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001387 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001388 return ret;
1389}
1390DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1391
1392static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1393 struct se_ml_stat_grps *lgrps, char *page)
1394{
1395 struct se_lun_acl *lacl = container_of(lgrps,
1396 struct se_lun_acl, ml_stat_grps);
1397 struct se_node_acl *nacl = lacl->se_lun_nacl;
1398 struct se_dev_entry *deve;
1399 struct se_lun *lun;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001400 ssize_t ret;
1401
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001402 rcu_read_lock();
1403 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1404 if (!deve) {
1405 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001406 return -ENODEV;
1407 }
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001408 lun = rcu_dereference(deve->se_lun);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001409 /* scsiDeviceIndex */
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001410 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1411 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001412 return ret;
1413}
1414DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1415
1416static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1417 struct se_ml_stat_grps *lgrps, char *page)
1418{
1419 struct se_lun_acl *lacl = container_of(lgrps,
1420 struct se_lun_acl, ml_stat_grps);
1421 struct se_node_acl *nacl = lacl->se_lun_nacl;
1422 struct se_dev_entry *deve;
1423 struct se_portal_group *tpg;
1424 ssize_t ret;
1425
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001426 rcu_read_lock();
1427 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1428 if (!deve) {
1429 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001430 return -ENODEV;
1431 }
1432 tpg = nacl->se_tpg;
1433 /* scsiPortIndex */
Andy Grovere3d6f902011-07-19 08:55:10 +00001434 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001435 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001436 return ret;
1437}
1438DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1439
1440static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1441 struct se_ml_stat_grps *lgrps, char *page)
1442{
1443 struct se_lun_acl *lacl = container_of(lgrps,
1444 struct se_lun_acl, ml_stat_grps);
1445 struct se_node_acl *nacl = lacl->se_lun_nacl;
1446 struct se_session *se_sess;
1447 struct se_portal_group *tpg;
1448 ssize_t ret;
1449
1450 spin_lock_irq(&nacl->nacl_sess_lock);
1451 se_sess = nacl->nacl_sess;
1452 if (!se_sess) {
1453 spin_unlock_irq(&nacl->nacl_sess_lock);
1454 return -ENODEV;
1455 }
1456
1457 tpg = nacl->se_tpg;
1458 /* scsiAttIntrPortIndex */
1459 ret = snprintf(page, PAGE_SIZE, "%u\n",
Andy Grovere3d6f902011-07-19 08:55:10 +00001460 tpg->se_tpg_tfo->sess_get_index(se_sess));
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001461 spin_unlock_irq(&nacl->nacl_sess_lock);
1462 return ret;
1463}
1464DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1465
1466static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1467 struct se_ml_stat_grps *lgrps, char *page)
1468{
1469 struct se_lun_acl *lacl = container_of(lgrps,
1470 struct se_lun_acl, ml_stat_grps);
1471 struct se_node_acl *nacl = lacl->se_lun_nacl;
1472 struct se_dev_entry *deve;
1473 ssize_t ret;
1474
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001475 rcu_read_lock();
1476 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1477 if (!deve) {
1478 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001479 return -ENODEV;
1480 }
1481 /* scsiAttIntrPortAuthIntrIdx */
1482 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
Nicholas Bellinger29a05de2015-03-22 20:42:19 -07001483 rcu_read_unlock();
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001484 return ret;
1485}
1486DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1487
1488static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1489 struct se_ml_stat_grps *lgrps, char *page)
1490{
1491 struct se_lun_acl *lacl = container_of(lgrps,
1492 struct se_lun_acl, ml_stat_grps);
1493 struct se_node_acl *nacl = lacl->se_lun_nacl;
1494 struct se_session *se_sess;
1495 struct se_portal_group *tpg;
1496 ssize_t ret;
1497 unsigned char buf[64];
1498
1499 spin_lock_irq(&nacl->nacl_sess_lock);
1500 se_sess = nacl->nacl_sess;
1501 if (!se_sess) {
1502 spin_unlock_irq(&nacl->nacl_sess_lock);
1503 return -ENODEV;
1504 }
1505
1506 tpg = nacl->se_tpg;
1507 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1508 memset(buf, 0, 64);
Andy Grovere3d6f902011-07-19 08:55:10 +00001509 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
Jörn Engel8359cf42011-11-24 02:05:51 +01001510 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001511
1512 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1513 spin_unlock_irq(&nacl->nacl_sess_lock);
1514 return ret;
1515}
1516DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1517
1518CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1519 scsi_att_intr_port_group);
1520
1521static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1522 &target_stat_scsi_att_intr_port_inst.attr,
1523 &target_stat_scsi_att_intr_port_dev.attr,
1524 &target_stat_scsi_att_intr_port_port.attr,
1525 &target_stat_scsi_att_intr_port_indx.attr,
1526 &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1527 &target_stat_scsi_att_intr_port_port_ident.attr,
1528 NULL,
1529};
1530
1531static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1532 .show_attribute = target_stat_scsi_att_intr_port_attr_show,
1533 .store_attribute = target_stat_scsi_att_intr_port_attr_store,
1534};
1535
1536static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1537 .ct_item_ops = &target_stat_scsi_att_intr_port_attrib_ops,
1538 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1539 .ct_owner = THIS_MODULE,
1540};
1541
1542/*
1543 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1544 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1545 */
1546void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1547{
Andy Grovere3d6f902011-07-19 08:55:10 +00001548 struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001549
Andy Grovere3d6f902011-07-19 08:55:10 +00001550 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001551 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
Andy Grovere3d6f902011-07-19 08:55:10 +00001552 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001553 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1554
Andy Grovere3d6f902011-07-19 08:55:10 +00001555 ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1556 ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
Nicholas Bellinger12d2338422011-03-14 04:06:11 -07001557 ml_stat_grp->default_groups[2] = NULL;
1558}