1 /*******************************************************************************
2 * Filename: target_core_stat.c
4 * Copyright (c) 2011 Rising Tide Systems
5 * Copyright (c) 2011 Linux-iSCSI.org
7 * Modern ConfigFS group context specific statistics based on original
8 * target_core_mib.c code
10 * Copyright (c) 2006-2007 SBE, Inc. All Rights Reserved.
12 * Nicholas A. Bellinger <nab@linux-iscsi.org>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
28 ******************************************************************************/
30 #include <linux/kernel.h>
31 #include <linux/module.h>
32 #include <linux/delay.h>
33 #include <linux/timer.h>
34 #include <linux/string.h>
35 #include <linux/utsname.h>
36 #include <linux/proc_fs.h>
37 #include <linux/seq_file.h>
38 #include <linux/blkdev.h>
39 #include <linux/configfs.h>
40 #include <scsi/scsi.h>
41 #include <scsi/scsi_device.h>
42 #include <scsi/scsi_host.h>
44 #include <target/target_core_base.h>
45 #include <target/target_core_backend.h>
46 #include <target/target_core_fabric.h>
47 #include <target/target_core_configfs.h>
48 #include <target/configfs_macros.h>
50 #include "target_core_internal.h"
52 #ifndef INITIAL_JIFFIES
53 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
57 #define ISPRINT(a) ((a >= ' ') && (a <= '~'))
59 #define SCSI_LU_INDEX 1
66 CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
67 #define DEV_STAT_SCSI_DEV_ATTR(_name, _mode) \
68 static struct target_stat_scsi_dev_attribute \
69 target_stat_scsi_dev_##_name = \
70 __CONFIGFS_EATTR(_name, _mode, \
71 target_stat_scsi_dev_show_attr_##_name, \
72 target_stat_scsi_dev_store_attr_##_name);
74 #define DEV_STAT_SCSI_DEV_ATTR_RO(_name) \
75 static struct target_stat_scsi_dev_attribute \
76 target_stat_scsi_dev_##_name = \
77 __CONFIGFS_EATTR_RO(_name, \
78 target_stat_scsi_dev_show_attr_##_name);
80 static ssize_t target_stat_scsi_dev_show_attr_inst(
81 struct se_dev_stat_grps *sgrps, char *page)
83 struct se_subsystem_dev *se_subdev = container_of(sgrps,
84 struct se_subsystem_dev, dev_stat_grps);
85 struct se_hba *hba = se_subdev->se_dev_hba;
86 struct se_device *dev = se_subdev->se_dev_ptr;
91 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
93 DEV_STAT_SCSI_DEV_ATTR_RO(inst);
95 static ssize_t target_stat_scsi_dev_show_attr_indx(
96 struct se_dev_stat_grps *sgrps, char *page)
98 struct se_subsystem_dev *se_subdev = container_of(sgrps,
99 struct se_subsystem_dev, dev_stat_grps);
100 struct se_device *dev = se_subdev->se_dev_ptr;
105 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
107 DEV_STAT_SCSI_DEV_ATTR_RO(indx);
109 static ssize_t target_stat_scsi_dev_show_attr_role(
110 struct se_dev_stat_grps *sgrps, char *page)
112 struct se_subsystem_dev *se_subdev = container_of(sgrps,
113 struct se_subsystem_dev, dev_stat_grps);
114 struct se_device *dev = se_subdev->se_dev_ptr;
119 return snprintf(page, PAGE_SIZE, "Target\n");
121 DEV_STAT_SCSI_DEV_ATTR_RO(role);
123 static ssize_t target_stat_scsi_dev_show_attr_ports(
124 struct se_dev_stat_grps *sgrps, char *page)
126 struct se_subsystem_dev *se_subdev = container_of(sgrps,
127 struct se_subsystem_dev, dev_stat_grps);
128 struct se_device *dev = se_subdev->se_dev_ptr;
133 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
135 DEV_STAT_SCSI_DEV_ATTR_RO(ports);
137 CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
139 static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
140 &target_stat_scsi_dev_inst.attr,
141 &target_stat_scsi_dev_indx.attr,
142 &target_stat_scsi_dev_role.attr,
143 &target_stat_scsi_dev_ports.attr,
147 static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
148 .show_attribute = target_stat_scsi_dev_attr_show,
149 .store_attribute = target_stat_scsi_dev_attr_store,
152 static struct config_item_type target_stat_scsi_dev_cit = {
153 .ct_item_ops = &target_stat_scsi_dev_attrib_ops,
154 .ct_attrs = target_stat_scsi_dev_attrs,
155 .ct_owner = THIS_MODULE,
159 * SCSI Target Device Table
162 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
163 #define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode) \
164 static struct target_stat_scsi_tgt_dev_attribute \
165 target_stat_scsi_tgt_dev_##_name = \
166 __CONFIGFS_EATTR(_name, _mode, \
167 target_stat_scsi_tgt_dev_show_attr_##_name, \
168 target_stat_scsi_tgt_dev_store_attr_##_name);
170 #define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name) \
171 static struct target_stat_scsi_tgt_dev_attribute \
172 target_stat_scsi_tgt_dev_##_name = \
173 __CONFIGFS_EATTR_RO(_name, \
174 target_stat_scsi_tgt_dev_show_attr_##_name);
176 static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
177 struct se_dev_stat_grps *sgrps, char *page)
179 struct se_subsystem_dev *se_subdev = container_of(sgrps,
180 struct se_subsystem_dev, dev_stat_grps);
181 struct se_hba *hba = se_subdev->se_dev_hba;
182 struct se_device *dev = se_subdev->se_dev_ptr;
187 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
189 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
191 static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
192 struct se_dev_stat_grps *sgrps, char *page)
194 struct se_subsystem_dev *se_subdev = container_of(sgrps,
195 struct se_subsystem_dev, dev_stat_grps);
196 struct se_device *dev = se_subdev->se_dev_ptr;
201 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
203 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
205 static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
206 struct se_dev_stat_grps *sgrps, char *page)
208 struct se_subsystem_dev *se_subdev = container_of(sgrps,
209 struct se_subsystem_dev, dev_stat_grps);
210 struct se_device *dev = se_subdev->se_dev_ptr;
215 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
217 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
219 static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
220 struct se_dev_stat_grps *sgrps, char *page)
222 struct se_subsystem_dev *se_subdev = container_of(sgrps,
223 struct se_subsystem_dev, dev_stat_grps);
224 struct se_device *dev = se_subdev->se_dev_ptr;
230 switch (dev->dev_status) {
231 case TRANSPORT_DEVICE_ACTIVATED:
232 strcpy(status, "activated");
234 case TRANSPORT_DEVICE_DEACTIVATED:
235 strcpy(status, "deactivated");
237 case TRANSPORT_DEVICE_SHUTDOWN:
238 strcpy(status, "shutdown");
240 case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
241 case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
242 strcpy(status, "offline");
245 sprintf(status, "unknown(%d)", dev->dev_status);
249 return snprintf(page, PAGE_SIZE, "%s\n", status);
251 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
253 static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
254 struct se_dev_stat_grps *sgrps, char *page)
256 struct se_subsystem_dev *se_subdev = container_of(sgrps,
257 struct se_subsystem_dev, dev_stat_grps);
258 struct se_device *dev = se_subdev->se_dev_ptr;
259 int non_accessible_lus;
264 switch (dev->dev_status) {
265 case TRANSPORT_DEVICE_ACTIVATED:
266 non_accessible_lus = 0;
268 case TRANSPORT_DEVICE_DEACTIVATED:
269 case TRANSPORT_DEVICE_SHUTDOWN:
270 case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
271 case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
273 non_accessible_lus = 1;
277 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
279 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
281 static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
282 struct se_dev_stat_grps *sgrps, char *page)
284 struct se_subsystem_dev *se_subdev = container_of(sgrps,
285 struct se_subsystem_dev, dev_stat_grps);
286 struct se_device *dev = se_subdev->se_dev_ptr;
291 return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
293 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
296 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
298 static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
299 &target_stat_scsi_tgt_dev_inst.attr,
300 &target_stat_scsi_tgt_dev_indx.attr,
301 &target_stat_scsi_tgt_dev_num_lus.attr,
302 &target_stat_scsi_tgt_dev_status.attr,
303 &target_stat_scsi_tgt_dev_non_access_lus.attr,
304 &target_stat_scsi_tgt_dev_resets.attr,
308 static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
309 .show_attribute = target_stat_scsi_tgt_dev_attr_show,
310 .store_attribute = target_stat_scsi_tgt_dev_attr_store,
313 static struct config_item_type target_stat_scsi_tgt_dev_cit = {
314 .ct_item_ops = &target_stat_scsi_tgt_dev_attrib_ops,
315 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
316 .ct_owner = THIS_MODULE,
320 * SCSI Logical Unit Table
323 CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
324 #define DEV_STAT_SCSI_LU_ATTR(_name, _mode) \
325 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
326 __CONFIGFS_EATTR(_name, _mode, \
327 target_stat_scsi_lu_show_attr_##_name, \
328 target_stat_scsi_lu_store_attr_##_name);
330 #define DEV_STAT_SCSI_LU_ATTR_RO(_name) \
331 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
332 __CONFIGFS_EATTR_RO(_name, \
333 target_stat_scsi_lu_show_attr_##_name);
335 static ssize_t target_stat_scsi_lu_show_attr_inst(
336 struct se_dev_stat_grps *sgrps, char *page)
338 struct se_subsystem_dev *se_subdev = container_of(sgrps,
339 struct se_subsystem_dev, dev_stat_grps);
340 struct se_hba *hba = se_subdev->se_dev_hba;
341 struct se_device *dev = se_subdev->se_dev_ptr;
346 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
348 DEV_STAT_SCSI_LU_ATTR_RO(inst);
350 static ssize_t target_stat_scsi_lu_show_attr_dev(
351 struct se_dev_stat_grps *sgrps, char *page)
353 struct se_subsystem_dev *se_subdev = container_of(sgrps,
354 struct se_subsystem_dev, dev_stat_grps);
355 struct se_device *dev = se_subdev->se_dev_ptr;
360 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
362 DEV_STAT_SCSI_LU_ATTR_RO(dev);
364 static ssize_t target_stat_scsi_lu_show_attr_indx(
365 struct se_dev_stat_grps *sgrps, char *page)
367 struct se_subsystem_dev *se_subdev = container_of(sgrps,
368 struct se_subsystem_dev, dev_stat_grps);
369 struct se_device *dev = se_subdev->se_dev_ptr;
374 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
376 DEV_STAT_SCSI_LU_ATTR_RO(indx);
378 static ssize_t target_stat_scsi_lu_show_attr_lun(
379 struct se_dev_stat_grps *sgrps, char *page)
381 struct se_subsystem_dev *se_subdev = container_of(sgrps,
382 struct se_subsystem_dev, dev_stat_grps);
383 struct se_device *dev = se_subdev->se_dev_ptr;
387 /* FIXME: scsiLuDefaultLun */
388 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
390 DEV_STAT_SCSI_LU_ATTR_RO(lun);
392 static ssize_t target_stat_scsi_lu_show_attr_lu_name(
393 struct se_dev_stat_grps *sgrps, char *page)
395 struct se_subsystem_dev *se_subdev = container_of(sgrps,
396 struct se_subsystem_dev, dev_stat_grps);
397 struct se_device *dev = se_subdev->se_dev_ptr;
402 return snprintf(page, PAGE_SIZE, "%s\n",
403 (strlen(dev->se_sub_dev->t10_wwn.unit_serial)) ?
404 dev->se_sub_dev->t10_wwn.unit_serial : "None");
406 DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
408 static ssize_t target_stat_scsi_lu_show_attr_vend(
409 struct se_dev_stat_grps *sgrps, char *page)
411 struct se_subsystem_dev *se_subdev = container_of(sgrps,
412 struct se_subsystem_dev, dev_stat_grps);
413 struct se_device *dev = se_subdev->se_dev_ptr;
415 char str[sizeof(dev->se_sub_dev->t10_wwn.vendor)+1];
421 for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
422 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.vendor[i]) ?
423 dev->se_sub_dev->t10_wwn.vendor[i] : ' ';
425 return snprintf(page, PAGE_SIZE, "%s\n", str);
427 DEV_STAT_SCSI_LU_ATTR_RO(vend);
429 static ssize_t target_stat_scsi_lu_show_attr_prod(
430 struct se_dev_stat_grps *sgrps, char *page)
432 struct se_subsystem_dev *se_subdev = container_of(sgrps,
433 struct se_subsystem_dev, dev_stat_grps);
434 struct se_device *dev = se_subdev->se_dev_ptr;
436 char str[sizeof(dev->se_sub_dev->t10_wwn.model)+1];
441 /* scsiLuProductId */
442 for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
443 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.model[i]) ?
444 dev->se_sub_dev->t10_wwn.model[i] : ' ';
446 return snprintf(page, PAGE_SIZE, "%s\n", str);
448 DEV_STAT_SCSI_LU_ATTR_RO(prod);
450 static ssize_t target_stat_scsi_lu_show_attr_rev(
451 struct se_dev_stat_grps *sgrps, char *page)
453 struct se_subsystem_dev *se_subdev = container_of(sgrps,
454 struct se_subsystem_dev, dev_stat_grps);
455 struct se_device *dev = se_subdev->se_dev_ptr;
457 char str[sizeof(dev->se_sub_dev->t10_wwn.revision)+1];
462 /* scsiLuRevisionId */
463 for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.revision); i++)
464 str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.revision[i]) ?
465 dev->se_sub_dev->t10_wwn.revision[i] : ' ';
467 return snprintf(page, PAGE_SIZE, "%s\n", str);
469 DEV_STAT_SCSI_LU_ATTR_RO(rev);
471 static ssize_t target_stat_scsi_lu_show_attr_dev_type(
472 struct se_dev_stat_grps *sgrps, char *page)
474 struct se_subsystem_dev *se_subdev = container_of(sgrps,
475 struct se_subsystem_dev, dev_stat_grps);
476 struct se_device *dev = se_subdev->se_dev_ptr;
481 /* scsiLuPeripheralType */
482 return snprintf(page, PAGE_SIZE, "%u\n",
483 dev->transport->get_device_type(dev));
485 DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
487 static ssize_t target_stat_scsi_lu_show_attr_status(
488 struct se_dev_stat_grps *sgrps, char *page)
490 struct se_subsystem_dev *se_subdev = container_of(sgrps,
491 struct se_subsystem_dev, dev_stat_grps);
492 struct se_device *dev = se_subdev->se_dev_ptr;
498 return snprintf(page, PAGE_SIZE, "%s\n",
499 (dev->dev_status == TRANSPORT_DEVICE_ACTIVATED) ?
500 "available" : "notavailable");
502 DEV_STAT_SCSI_LU_ATTR_RO(status);
504 static ssize_t target_stat_scsi_lu_show_attr_state_bit(
505 struct se_dev_stat_grps *sgrps, char *page)
507 struct se_subsystem_dev *se_subdev = container_of(sgrps,
508 struct se_subsystem_dev, dev_stat_grps);
509 struct se_device *dev = se_subdev->se_dev_ptr;
515 return snprintf(page, PAGE_SIZE, "exposed\n");
517 DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
519 static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
520 struct se_dev_stat_grps *sgrps, char *page)
522 struct se_subsystem_dev *se_subdev = container_of(sgrps,
523 struct se_subsystem_dev, dev_stat_grps);
524 struct se_device *dev = se_subdev->se_dev_ptr;
529 /* scsiLuNumCommands */
530 return snprintf(page, PAGE_SIZE, "%llu\n",
531 (unsigned long long)dev->num_cmds);
533 DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
535 static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
536 struct se_dev_stat_grps *sgrps, char *page)
538 struct se_subsystem_dev *se_subdev = container_of(sgrps,
539 struct se_subsystem_dev, dev_stat_grps);
540 struct se_device *dev = se_subdev->se_dev_ptr;
545 /* scsiLuReadMegaBytes */
546 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->read_bytes >> 20));
548 DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
550 static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
551 struct se_dev_stat_grps *sgrps, char *page)
553 struct se_subsystem_dev *se_subdev = container_of(sgrps,
554 struct se_subsystem_dev, dev_stat_grps);
555 struct se_device *dev = se_subdev->se_dev_ptr;
560 /* scsiLuWrittenMegaBytes */
561 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->write_bytes >> 20));
563 DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
565 static ssize_t target_stat_scsi_lu_show_attr_resets(
566 struct se_dev_stat_grps *sgrps, char *page)
568 struct se_subsystem_dev *se_subdev = container_of(sgrps,
569 struct se_subsystem_dev, dev_stat_grps);
570 struct se_device *dev = se_subdev->se_dev_ptr;
576 return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
578 DEV_STAT_SCSI_LU_ATTR_RO(resets);
580 static ssize_t target_stat_scsi_lu_show_attr_full_stat(
581 struct se_dev_stat_grps *sgrps, char *page)
583 struct se_subsystem_dev *se_subdev = container_of(sgrps,
584 struct se_subsystem_dev, dev_stat_grps);
585 struct se_device *dev = se_subdev->se_dev_ptr;
590 /* FIXME: scsiLuOutTaskSetFullStatus */
591 return snprintf(page, PAGE_SIZE, "%u\n", 0);
593 DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
595 static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
596 struct se_dev_stat_grps *sgrps, char *page)
598 struct se_subsystem_dev *se_subdev = container_of(sgrps,
599 struct se_subsystem_dev, dev_stat_grps);
600 struct se_device *dev = se_subdev->se_dev_ptr;
605 /* FIXME: scsiLuHSInCommands */
606 return snprintf(page, PAGE_SIZE, "%u\n", 0);
608 DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
610 static ssize_t target_stat_scsi_lu_show_attr_creation_time(
611 struct se_dev_stat_grps *sgrps, char *page)
613 struct se_subsystem_dev *se_subdev = container_of(sgrps,
614 struct se_subsystem_dev, dev_stat_grps);
615 struct se_device *dev = se_subdev->se_dev_ptr;
620 /* scsiLuCreationTime */
621 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
622 INITIAL_JIFFIES) * 100 / HZ));
624 DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
626 CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
628 static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
629 &target_stat_scsi_lu_inst.attr,
630 &target_stat_scsi_lu_dev.attr,
631 &target_stat_scsi_lu_indx.attr,
632 &target_stat_scsi_lu_lun.attr,
633 &target_stat_scsi_lu_lu_name.attr,
634 &target_stat_scsi_lu_vend.attr,
635 &target_stat_scsi_lu_prod.attr,
636 &target_stat_scsi_lu_rev.attr,
637 &target_stat_scsi_lu_dev_type.attr,
638 &target_stat_scsi_lu_status.attr,
639 &target_stat_scsi_lu_state_bit.attr,
640 &target_stat_scsi_lu_num_cmds.attr,
641 &target_stat_scsi_lu_read_mbytes.attr,
642 &target_stat_scsi_lu_write_mbytes.attr,
643 &target_stat_scsi_lu_resets.attr,
644 &target_stat_scsi_lu_full_stat.attr,
645 &target_stat_scsi_lu_hs_num_cmds.attr,
646 &target_stat_scsi_lu_creation_time.attr,
650 static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
651 .show_attribute = target_stat_scsi_lu_attr_show,
652 .store_attribute = target_stat_scsi_lu_attr_store,
655 static struct config_item_type target_stat_scsi_lu_cit = {
656 .ct_item_ops = &target_stat_scsi_lu_attrib_ops,
657 .ct_attrs = target_stat_scsi_lu_attrs,
658 .ct_owner = THIS_MODULE,
662 * Called from target_core_configfs.c:target_core_make_subdev() to setup
663 * the target statistics groups + configfs CITs located in target_core_stat.c
665 void target_stat_setup_dev_default_groups(struct se_subsystem_dev *se_subdev)
667 struct config_group *dev_stat_grp = &se_subdev->dev_stat_grps.stat_group;
669 config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_dev_group,
670 "scsi_dev", &target_stat_scsi_dev_cit);
671 config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_tgt_dev_group,
672 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
673 config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_lu_group,
674 "scsi_lu", &target_stat_scsi_lu_cit);
676 dev_stat_grp->default_groups[0] = &se_subdev->dev_stat_grps.scsi_dev_group;
677 dev_stat_grp->default_groups[1] = &se_subdev->dev_stat_grps.scsi_tgt_dev_group;
678 dev_stat_grp->default_groups[2] = &se_subdev->dev_stat_grps.scsi_lu_group;
679 dev_stat_grp->default_groups[3] = NULL;
686 CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
687 #define DEV_STAT_SCSI_PORT_ATTR(_name, _mode) \
688 static struct target_stat_scsi_port_attribute \
689 target_stat_scsi_port_##_name = \
690 __CONFIGFS_EATTR(_name, _mode, \
691 target_stat_scsi_port_show_attr_##_name, \
692 target_stat_scsi_port_store_attr_##_name);
694 #define DEV_STAT_SCSI_PORT_ATTR_RO(_name) \
695 static struct target_stat_scsi_port_attribute \
696 target_stat_scsi_port_##_name = \
697 __CONFIGFS_EATTR_RO(_name, \
698 target_stat_scsi_port_show_attr_##_name);
700 static ssize_t target_stat_scsi_port_show_attr_inst(
701 struct se_port_stat_grps *pgrps, char *page)
703 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
705 struct se_device *dev = lun->lun_se_dev;
709 spin_lock(&lun->lun_sep_lock);
712 spin_unlock(&lun->lun_sep_lock);
716 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
717 spin_unlock(&lun->lun_sep_lock);
720 DEV_STAT_SCSI_PORT_ATTR_RO(inst);
722 static ssize_t target_stat_scsi_port_show_attr_dev(
723 struct se_port_stat_grps *pgrps, char *page)
725 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
727 struct se_device *dev = lun->lun_se_dev;
730 spin_lock(&lun->lun_sep_lock);
733 spin_unlock(&lun->lun_sep_lock);
736 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
737 spin_unlock(&lun->lun_sep_lock);
740 DEV_STAT_SCSI_PORT_ATTR_RO(dev);
742 static ssize_t target_stat_scsi_port_show_attr_indx(
743 struct se_port_stat_grps *pgrps, char *page)
745 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
749 spin_lock(&lun->lun_sep_lock);
752 spin_unlock(&lun->lun_sep_lock);
755 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
756 spin_unlock(&lun->lun_sep_lock);
759 DEV_STAT_SCSI_PORT_ATTR_RO(indx);
761 static ssize_t target_stat_scsi_port_show_attr_role(
762 struct se_port_stat_grps *pgrps, char *page)
764 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
765 struct se_device *dev = lun->lun_se_dev;
772 spin_lock(&lun->lun_sep_lock);
775 spin_unlock(&lun->lun_sep_lock);
778 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
779 spin_unlock(&lun->lun_sep_lock);
782 DEV_STAT_SCSI_PORT_ATTR_RO(role);
784 static ssize_t target_stat_scsi_port_show_attr_busy_count(
785 struct se_port_stat_grps *pgrps, char *page)
787 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
791 spin_lock(&lun->lun_sep_lock);
794 spin_unlock(&lun->lun_sep_lock);
797 /* FIXME: scsiPortBusyStatuses */
798 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
799 spin_unlock(&lun->lun_sep_lock);
802 DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
804 CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
806 static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
807 &target_stat_scsi_port_inst.attr,
808 &target_stat_scsi_port_dev.attr,
809 &target_stat_scsi_port_indx.attr,
810 &target_stat_scsi_port_role.attr,
811 &target_stat_scsi_port_busy_count.attr,
815 static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
816 .show_attribute = target_stat_scsi_port_attr_show,
817 .store_attribute = target_stat_scsi_port_attr_store,
820 static struct config_item_type target_stat_scsi_port_cit = {
821 .ct_item_ops = &target_stat_scsi_port_attrib_ops,
822 .ct_attrs = target_stat_scsi_port_attrs,
823 .ct_owner = THIS_MODULE,
827 * SCSI Target Port Table
829 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
830 #define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode) \
831 static struct target_stat_scsi_tgt_port_attribute \
832 target_stat_scsi_tgt_port_##_name = \
833 __CONFIGFS_EATTR(_name, _mode, \
834 target_stat_scsi_tgt_port_show_attr_##_name, \
835 target_stat_scsi_tgt_port_store_attr_##_name);
837 #define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name) \
838 static struct target_stat_scsi_tgt_port_attribute \
839 target_stat_scsi_tgt_port_##_name = \
840 __CONFIGFS_EATTR_RO(_name, \
841 target_stat_scsi_tgt_port_show_attr_##_name);
843 static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
844 struct se_port_stat_grps *pgrps, char *page)
846 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
847 struct se_device *dev = lun->lun_se_dev;
852 spin_lock(&lun->lun_sep_lock);
855 spin_unlock(&lun->lun_sep_lock);
859 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
860 spin_unlock(&lun->lun_sep_lock);
863 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
865 static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
866 struct se_port_stat_grps *pgrps, char *page)
868 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
869 struct se_device *dev = lun->lun_se_dev;
873 spin_lock(&lun->lun_sep_lock);
876 spin_unlock(&lun->lun_sep_lock);
879 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
880 spin_unlock(&lun->lun_sep_lock);
883 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
885 static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
886 struct se_port_stat_grps *pgrps, char *page)
888 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
892 spin_lock(&lun->lun_sep_lock);
895 spin_unlock(&lun->lun_sep_lock);
898 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
899 spin_unlock(&lun->lun_sep_lock);
902 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
904 static ssize_t target_stat_scsi_tgt_port_show_attr_name(
905 struct se_port_stat_grps *pgrps, char *page)
907 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
909 struct se_portal_group *tpg;
912 spin_lock(&lun->lun_sep_lock);
915 spin_unlock(&lun->lun_sep_lock);
920 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
921 tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
922 spin_unlock(&lun->lun_sep_lock);
925 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
927 static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
928 struct se_port_stat_grps *pgrps, char *page)
930 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
932 struct se_portal_group *tpg;
935 spin_lock(&lun->lun_sep_lock);
938 spin_unlock(&lun->lun_sep_lock);
943 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
944 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
945 tpg->se_tpg_tfo->tpg_get_tag(tpg));
946 spin_unlock(&lun->lun_sep_lock);
949 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
951 static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
952 struct se_port_stat_grps *pgrps, char *page)
954 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
958 spin_lock(&lun->lun_sep_lock);
961 spin_unlock(&lun->lun_sep_lock);
965 ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
966 spin_unlock(&lun->lun_sep_lock);
969 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
971 static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
972 struct se_port_stat_grps *pgrps, char *page)
974 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
978 spin_lock(&lun->lun_sep_lock);
981 spin_unlock(&lun->lun_sep_lock);
985 ret = snprintf(page, PAGE_SIZE, "%u\n",
986 (u32)(sep->sep_stats.rx_data_octets >> 20));
987 spin_unlock(&lun->lun_sep_lock);
990 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
992 static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
993 struct se_port_stat_grps *pgrps, char *page)
995 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
999 spin_lock(&lun->lun_sep_lock);
1002 spin_unlock(&lun->lun_sep_lock);
1006 ret = snprintf(page, PAGE_SIZE, "%u\n",
1007 (u32)(sep->sep_stats.tx_data_octets >> 20));
1008 spin_unlock(&lun->lun_sep_lock);
1011 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
1013 static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
1014 struct se_port_stat_grps *pgrps, char *page)
1016 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1017 struct se_port *sep;
1020 spin_lock(&lun->lun_sep_lock);
1023 spin_unlock(&lun->lun_sep_lock);
1027 /* FIXME: scsiTgtPortHsInCommands */
1028 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1029 spin_unlock(&lun->lun_sep_lock);
1032 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
1034 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
1035 scsi_tgt_port_group);
1037 static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
1038 &target_stat_scsi_tgt_port_inst.attr,
1039 &target_stat_scsi_tgt_port_dev.attr,
1040 &target_stat_scsi_tgt_port_indx.attr,
1041 &target_stat_scsi_tgt_port_name.attr,
1042 &target_stat_scsi_tgt_port_port_index.attr,
1043 &target_stat_scsi_tgt_port_in_cmds.attr,
1044 &target_stat_scsi_tgt_port_write_mbytes.attr,
1045 &target_stat_scsi_tgt_port_read_mbytes.attr,
1046 &target_stat_scsi_tgt_port_hs_in_cmds.attr,
1050 static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
1051 .show_attribute = target_stat_scsi_tgt_port_attr_show,
1052 .store_attribute = target_stat_scsi_tgt_port_attr_store,
1055 static struct config_item_type target_stat_scsi_tgt_port_cit = {
1056 .ct_item_ops = &target_stat_scsi_tgt_port_attrib_ops,
1057 .ct_attrs = target_stat_scsi_tgt_port_attrs,
1058 .ct_owner = THIS_MODULE,
1062 * SCSI Transport Table
1065 CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
1066 #define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode) \
1067 static struct target_stat_scsi_transport_attribute \
1068 target_stat_scsi_transport_##_name = \
1069 __CONFIGFS_EATTR(_name, _mode, \
1070 target_stat_scsi_transport_show_attr_##_name, \
1071 target_stat_scsi_transport_store_attr_##_name);
1073 #define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name) \
1074 static struct target_stat_scsi_transport_attribute \
1075 target_stat_scsi_transport_##_name = \
1076 __CONFIGFS_EATTR_RO(_name, \
1077 target_stat_scsi_transport_show_attr_##_name);
1079 static ssize_t target_stat_scsi_transport_show_attr_inst(
1080 struct se_port_stat_grps *pgrps, char *page)
1082 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1083 struct se_device *dev = lun->lun_se_dev;
1084 struct se_port *sep;
1088 spin_lock(&lun->lun_sep_lock);
1091 spin_unlock(&lun->lun_sep_lock);
1096 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
1097 spin_unlock(&lun->lun_sep_lock);
1100 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
1102 static ssize_t target_stat_scsi_transport_show_attr_device(
1103 struct se_port_stat_grps *pgrps, char *page)
1105 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1106 struct se_port *sep;
1107 struct se_portal_group *tpg;
1110 spin_lock(&lun->lun_sep_lock);
1113 spin_unlock(&lun->lun_sep_lock);
1117 /* scsiTransportType */
1118 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
1119 tpg->se_tpg_tfo->get_fabric_name());
1120 spin_unlock(&lun->lun_sep_lock);
1123 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
1125 static ssize_t target_stat_scsi_transport_show_attr_indx(
1126 struct se_port_stat_grps *pgrps, char *page)
1128 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1129 struct se_port *sep;
1130 struct se_portal_group *tpg;
1133 spin_lock(&lun->lun_sep_lock);
1136 spin_unlock(&lun->lun_sep_lock);
1140 ret = snprintf(page, PAGE_SIZE, "%u\n",
1141 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1142 spin_unlock(&lun->lun_sep_lock);
1145 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
1147 static ssize_t target_stat_scsi_transport_show_attr_dev_name(
1148 struct se_port_stat_grps *pgrps, char *page)
1150 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1151 struct se_device *dev = lun->lun_se_dev;
1152 struct se_port *sep;
1153 struct se_portal_group *tpg;
1154 struct t10_wwn *wwn;
1157 spin_lock(&lun->lun_sep_lock);
1160 spin_unlock(&lun->lun_sep_lock);
1164 wwn = &dev->se_sub_dev->t10_wwn;
1165 /* scsiTransportDevName */
1166 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1167 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1168 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
1170 spin_unlock(&lun->lun_sep_lock);
1173 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1175 CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1176 scsi_transport_group);
1178 static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1179 &target_stat_scsi_transport_inst.attr,
1180 &target_stat_scsi_transport_device.attr,
1181 &target_stat_scsi_transport_indx.attr,
1182 &target_stat_scsi_transport_dev_name.attr,
1186 static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1187 .show_attribute = target_stat_scsi_transport_attr_show,
1188 .store_attribute = target_stat_scsi_transport_attr_store,
1191 static struct config_item_type target_stat_scsi_transport_cit = {
1192 .ct_item_ops = &target_stat_scsi_transport_attrib_ops,
1193 .ct_attrs = target_stat_scsi_transport_attrs,
1194 .ct_owner = THIS_MODULE,
1198 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1199 * the target port statistics groups + configfs CITs located in target_core_stat.c
1201 void target_stat_setup_port_default_groups(struct se_lun *lun)
1203 struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1205 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1206 "scsi_port", &target_stat_scsi_port_cit);
1207 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1208 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1209 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1210 "scsi_transport", &target_stat_scsi_transport_cit);
1212 port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1213 port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1214 port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1215 port_stat_grp->default_groups[3] = NULL;
1219 * SCSI Authorized Initiator Table
1222 CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1223 #define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode) \
1224 static struct target_stat_scsi_auth_intr_attribute \
1225 target_stat_scsi_auth_intr_##_name = \
1226 __CONFIGFS_EATTR(_name, _mode, \
1227 target_stat_scsi_auth_intr_show_attr_##_name, \
1228 target_stat_scsi_auth_intr_store_attr_##_name);
1230 #define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name) \
1231 static struct target_stat_scsi_auth_intr_attribute \
1232 target_stat_scsi_auth_intr_##_name = \
1233 __CONFIGFS_EATTR_RO(_name, \
1234 target_stat_scsi_auth_intr_show_attr_##_name);
1236 static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1237 struct se_ml_stat_grps *lgrps, char *page)
1239 struct se_lun_acl *lacl = container_of(lgrps,
1240 struct se_lun_acl, ml_stat_grps);
1241 struct se_node_acl *nacl = lacl->se_lun_nacl;
1242 struct se_dev_entry *deve;
1243 struct se_portal_group *tpg;
1246 spin_lock_irq(&nacl->device_list_lock);
1247 deve = nacl->device_list[lacl->mapped_lun];
1248 if (!deve->se_lun || !deve->se_lun_acl) {
1249 spin_unlock_irq(&nacl->device_list_lock);
1254 ret = snprintf(page, PAGE_SIZE, "%u\n",
1255 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1256 spin_unlock_irq(&nacl->device_list_lock);
1259 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1261 static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1262 struct se_ml_stat_grps *lgrps, char *page)
1264 struct se_lun_acl *lacl = container_of(lgrps,
1265 struct se_lun_acl, ml_stat_grps);
1266 struct se_node_acl *nacl = lacl->se_lun_nacl;
1267 struct se_dev_entry *deve;
1271 spin_lock_irq(&nacl->device_list_lock);
1272 deve = nacl->device_list[lacl->mapped_lun];
1273 if (!deve->se_lun || !deve->se_lun_acl) {
1274 spin_unlock_irq(&nacl->device_list_lock);
1278 /* scsiDeviceIndex */
1279 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1280 spin_unlock_irq(&nacl->device_list_lock);
1283 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1285 static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1286 struct se_ml_stat_grps *lgrps, char *page)
1288 struct se_lun_acl *lacl = container_of(lgrps,
1289 struct se_lun_acl, ml_stat_grps);
1290 struct se_node_acl *nacl = lacl->se_lun_nacl;
1291 struct se_dev_entry *deve;
1292 struct se_portal_group *tpg;
1295 spin_lock_irq(&nacl->device_list_lock);
1296 deve = nacl->device_list[lacl->mapped_lun];
1297 if (!deve->se_lun || !deve->se_lun_acl) {
1298 spin_unlock_irq(&nacl->device_list_lock);
1302 /* scsiAuthIntrTgtPortIndex */
1303 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1304 spin_unlock_irq(&nacl->device_list_lock);
1307 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1309 static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1310 struct se_ml_stat_grps *lgrps, char *page)
1312 struct se_lun_acl *lacl = container_of(lgrps,
1313 struct se_lun_acl, ml_stat_grps);
1314 struct se_node_acl *nacl = lacl->se_lun_nacl;
1315 struct se_dev_entry *deve;
1318 spin_lock_irq(&nacl->device_list_lock);
1319 deve = nacl->device_list[lacl->mapped_lun];
1320 if (!deve->se_lun || !deve->se_lun_acl) {
1321 spin_unlock_irq(&nacl->device_list_lock);
1324 /* scsiAuthIntrIndex */
1325 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1326 spin_unlock_irq(&nacl->device_list_lock);
1329 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1331 static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1332 struct se_ml_stat_grps *lgrps, char *page)
1334 struct se_lun_acl *lacl = container_of(lgrps,
1335 struct se_lun_acl, ml_stat_grps);
1336 struct se_node_acl *nacl = lacl->se_lun_nacl;
1337 struct se_dev_entry *deve;
1340 spin_lock_irq(&nacl->device_list_lock);
1341 deve = nacl->device_list[lacl->mapped_lun];
1342 if (!deve->se_lun || !deve->se_lun_acl) {
1343 spin_unlock_irq(&nacl->device_list_lock);
1346 /* scsiAuthIntrDevOrPort */
1347 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1348 spin_unlock_irq(&nacl->device_list_lock);
1351 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1353 static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1354 struct se_ml_stat_grps *lgrps, char *page)
1356 struct se_lun_acl *lacl = container_of(lgrps,
1357 struct se_lun_acl, ml_stat_grps);
1358 struct se_node_acl *nacl = lacl->se_lun_nacl;
1359 struct se_dev_entry *deve;
1362 spin_lock_irq(&nacl->device_list_lock);
1363 deve = nacl->device_list[lacl->mapped_lun];
1364 if (!deve->se_lun || !deve->se_lun_acl) {
1365 spin_unlock_irq(&nacl->device_list_lock);
1368 /* scsiAuthIntrName */
1369 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1370 spin_unlock_irq(&nacl->device_list_lock);
1373 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1375 static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1376 struct se_ml_stat_grps *lgrps, char *page)
1378 struct se_lun_acl *lacl = container_of(lgrps,
1379 struct se_lun_acl, ml_stat_grps);
1380 struct se_node_acl *nacl = lacl->se_lun_nacl;
1381 struct se_dev_entry *deve;
1384 spin_lock_irq(&nacl->device_list_lock);
1385 deve = nacl->device_list[lacl->mapped_lun];
1386 if (!deve->se_lun || !deve->se_lun_acl) {
1387 spin_unlock_irq(&nacl->device_list_lock);
1390 /* FIXME: scsiAuthIntrLunMapIndex */
1391 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1392 spin_unlock_irq(&nacl->device_list_lock);
1395 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1397 static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1398 struct se_ml_stat_grps *lgrps, char *page)
1400 struct se_lun_acl *lacl = container_of(lgrps,
1401 struct se_lun_acl, ml_stat_grps);
1402 struct se_node_acl *nacl = lacl->se_lun_nacl;
1403 struct se_dev_entry *deve;
1406 spin_lock_irq(&nacl->device_list_lock);
1407 deve = nacl->device_list[lacl->mapped_lun];
1408 if (!deve->se_lun || !deve->se_lun_acl) {
1409 spin_unlock_irq(&nacl->device_list_lock);
1412 /* scsiAuthIntrAttachedTimes */
1413 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1414 spin_unlock_irq(&nacl->device_list_lock);
1417 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1419 static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1420 struct se_ml_stat_grps *lgrps, char *page)
1422 struct se_lun_acl *lacl = container_of(lgrps,
1423 struct se_lun_acl, ml_stat_grps);
1424 struct se_node_acl *nacl = lacl->se_lun_nacl;
1425 struct se_dev_entry *deve;
1428 spin_lock_irq(&nacl->device_list_lock);
1429 deve = nacl->device_list[lacl->mapped_lun];
1430 if (!deve->se_lun || !deve->se_lun_acl) {
1431 spin_unlock_irq(&nacl->device_list_lock);
1434 /* scsiAuthIntrOutCommands */
1435 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1436 spin_unlock_irq(&nacl->device_list_lock);
1439 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1441 static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1442 struct se_ml_stat_grps *lgrps, char *page)
1444 struct se_lun_acl *lacl = container_of(lgrps,
1445 struct se_lun_acl, ml_stat_grps);
1446 struct se_node_acl *nacl = lacl->se_lun_nacl;
1447 struct se_dev_entry *deve;
1450 spin_lock_irq(&nacl->device_list_lock);
1451 deve = nacl->device_list[lacl->mapped_lun];
1452 if (!deve->se_lun || !deve->se_lun_acl) {
1453 spin_unlock_irq(&nacl->device_list_lock);
1456 /* scsiAuthIntrReadMegaBytes */
1457 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1458 spin_unlock_irq(&nacl->device_list_lock);
1461 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1463 static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1464 struct se_ml_stat_grps *lgrps, char *page)
1466 struct se_lun_acl *lacl = container_of(lgrps,
1467 struct se_lun_acl, ml_stat_grps);
1468 struct se_node_acl *nacl = lacl->se_lun_nacl;
1469 struct se_dev_entry *deve;
1472 spin_lock_irq(&nacl->device_list_lock);
1473 deve = nacl->device_list[lacl->mapped_lun];
1474 if (!deve->se_lun || !deve->se_lun_acl) {
1475 spin_unlock_irq(&nacl->device_list_lock);
1478 /* scsiAuthIntrWrittenMegaBytes */
1479 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1480 spin_unlock_irq(&nacl->device_list_lock);
1483 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1485 static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1486 struct se_ml_stat_grps *lgrps, char *page)
1488 struct se_lun_acl *lacl = container_of(lgrps,
1489 struct se_lun_acl, ml_stat_grps);
1490 struct se_node_acl *nacl = lacl->se_lun_nacl;
1491 struct se_dev_entry *deve;
1494 spin_lock_irq(&nacl->device_list_lock);
1495 deve = nacl->device_list[lacl->mapped_lun];
1496 if (!deve->se_lun || !deve->se_lun_acl) {
1497 spin_unlock_irq(&nacl->device_list_lock);
1500 /* FIXME: scsiAuthIntrHSOutCommands */
1501 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1502 spin_unlock_irq(&nacl->device_list_lock);
1505 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1507 static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1508 struct se_ml_stat_grps *lgrps, char *page)
1510 struct se_lun_acl *lacl = container_of(lgrps,
1511 struct se_lun_acl, ml_stat_grps);
1512 struct se_node_acl *nacl = lacl->se_lun_nacl;
1513 struct se_dev_entry *deve;
1516 spin_lock_irq(&nacl->device_list_lock);
1517 deve = nacl->device_list[lacl->mapped_lun];
1518 if (!deve->se_lun || !deve->se_lun_acl) {
1519 spin_unlock_irq(&nacl->device_list_lock);
1522 /* scsiAuthIntrLastCreation */
1523 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1524 INITIAL_JIFFIES) * 100 / HZ));
1525 spin_unlock_irq(&nacl->device_list_lock);
1528 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1530 static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1531 struct se_ml_stat_grps *lgrps, char *page)
1533 struct se_lun_acl *lacl = container_of(lgrps,
1534 struct se_lun_acl, ml_stat_grps);
1535 struct se_node_acl *nacl = lacl->se_lun_nacl;
1536 struct se_dev_entry *deve;
1539 spin_lock_irq(&nacl->device_list_lock);
1540 deve = nacl->device_list[lacl->mapped_lun];
1541 if (!deve->se_lun || !deve->se_lun_acl) {
1542 spin_unlock_irq(&nacl->device_list_lock);
1545 /* FIXME: scsiAuthIntrRowStatus */
1546 ret = snprintf(page, PAGE_SIZE, "Ready\n");
1547 spin_unlock_irq(&nacl->device_list_lock);
1550 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1552 CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1553 scsi_auth_intr_group);
1555 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1556 &target_stat_scsi_auth_intr_inst.attr,
1557 &target_stat_scsi_auth_intr_dev.attr,
1558 &target_stat_scsi_auth_intr_port.attr,
1559 &target_stat_scsi_auth_intr_indx.attr,
1560 &target_stat_scsi_auth_intr_dev_or_port.attr,
1561 &target_stat_scsi_auth_intr_intr_name.attr,
1562 &target_stat_scsi_auth_intr_map_indx.attr,
1563 &target_stat_scsi_auth_intr_att_count.attr,
1564 &target_stat_scsi_auth_intr_num_cmds.attr,
1565 &target_stat_scsi_auth_intr_read_mbytes.attr,
1566 &target_stat_scsi_auth_intr_write_mbytes.attr,
1567 &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1568 &target_stat_scsi_auth_intr_creation_time.attr,
1569 &target_stat_scsi_auth_intr_row_status.attr,
1573 static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1574 .show_attribute = target_stat_scsi_auth_intr_attr_show,
1575 .store_attribute = target_stat_scsi_auth_intr_attr_store,
1578 static struct config_item_type target_stat_scsi_auth_intr_cit = {
1579 .ct_item_ops = &target_stat_scsi_auth_intr_attrib_ops,
1580 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1581 .ct_owner = THIS_MODULE,
1585 * SCSI Attached Initiator Port Table
1588 CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1589 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode) \
1590 static struct target_stat_scsi_att_intr_port_attribute \
1591 target_stat_scsi_att_intr_port_##_name = \
1592 __CONFIGFS_EATTR(_name, _mode, \
1593 target_stat_scsi_att_intr_port_show_attr_##_name, \
1594 target_stat_scsi_att_intr_port_store_attr_##_name);
1596 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name) \
1597 static struct target_stat_scsi_att_intr_port_attribute \
1598 target_stat_scsi_att_intr_port_##_name = \
1599 __CONFIGFS_EATTR_RO(_name, \
1600 target_stat_scsi_att_intr_port_show_attr_##_name);
1602 static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1603 struct se_ml_stat_grps *lgrps, char *page)
1605 struct se_lun_acl *lacl = container_of(lgrps,
1606 struct se_lun_acl, ml_stat_grps);
1607 struct se_node_acl *nacl = lacl->se_lun_nacl;
1608 struct se_dev_entry *deve;
1609 struct se_portal_group *tpg;
1612 spin_lock_irq(&nacl->device_list_lock);
1613 deve = nacl->device_list[lacl->mapped_lun];
1614 if (!deve->se_lun || !deve->se_lun_acl) {
1615 spin_unlock_irq(&nacl->device_list_lock);
1620 ret = snprintf(page, PAGE_SIZE, "%u\n",
1621 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1622 spin_unlock_irq(&nacl->device_list_lock);
1625 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1627 static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1628 struct se_ml_stat_grps *lgrps, char *page)
1630 struct se_lun_acl *lacl = container_of(lgrps,
1631 struct se_lun_acl, ml_stat_grps);
1632 struct se_node_acl *nacl = lacl->se_lun_nacl;
1633 struct se_dev_entry *deve;
1637 spin_lock_irq(&nacl->device_list_lock);
1638 deve = nacl->device_list[lacl->mapped_lun];
1639 if (!deve->se_lun || !deve->se_lun_acl) {
1640 spin_unlock_irq(&nacl->device_list_lock);
1644 /* scsiDeviceIndex */
1645 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1646 spin_unlock_irq(&nacl->device_list_lock);
1649 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1651 static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1652 struct se_ml_stat_grps *lgrps, char *page)
1654 struct se_lun_acl *lacl = container_of(lgrps,
1655 struct se_lun_acl, ml_stat_grps);
1656 struct se_node_acl *nacl = lacl->se_lun_nacl;
1657 struct se_dev_entry *deve;
1658 struct se_portal_group *tpg;
1661 spin_lock_irq(&nacl->device_list_lock);
1662 deve = nacl->device_list[lacl->mapped_lun];
1663 if (!deve->se_lun || !deve->se_lun_acl) {
1664 spin_unlock_irq(&nacl->device_list_lock);
1669 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1670 spin_unlock_irq(&nacl->device_list_lock);
1673 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1675 static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1676 struct se_ml_stat_grps *lgrps, char *page)
1678 struct se_lun_acl *lacl = container_of(lgrps,
1679 struct se_lun_acl, ml_stat_grps);
1680 struct se_node_acl *nacl = lacl->se_lun_nacl;
1681 struct se_session *se_sess;
1682 struct se_portal_group *tpg;
1685 spin_lock_irq(&nacl->nacl_sess_lock);
1686 se_sess = nacl->nacl_sess;
1688 spin_unlock_irq(&nacl->nacl_sess_lock);
1693 /* scsiAttIntrPortIndex */
1694 ret = snprintf(page, PAGE_SIZE, "%u\n",
1695 tpg->se_tpg_tfo->sess_get_index(se_sess));
1696 spin_unlock_irq(&nacl->nacl_sess_lock);
1699 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1701 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1702 struct se_ml_stat_grps *lgrps, char *page)
1704 struct se_lun_acl *lacl = container_of(lgrps,
1705 struct se_lun_acl, ml_stat_grps);
1706 struct se_node_acl *nacl = lacl->se_lun_nacl;
1707 struct se_dev_entry *deve;
1710 spin_lock_irq(&nacl->device_list_lock);
1711 deve = nacl->device_list[lacl->mapped_lun];
1712 if (!deve->se_lun || !deve->se_lun_acl) {
1713 spin_unlock_irq(&nacl->device_list_lock);
1716 /* scsiAttIntrPortAuthIntrIdx */
1717 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1718 spin_unlock_irq(&nacl->device_list_lock);
1721 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1723 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1724 struct se_ml_stat_grps *lgrps, char *page)
1726 struct se_lun_acl *lacl = container_of(lgrps,
1727 struct se_lun_acl, ml_stat_grps);
1728 struct se_node_acl *nacl = lacl->se_lun_nacl;
1729 struct se_session *se_sess;
1730 struct se_portal_group *tpg;
1732 unsigned char buf[64];
1734 spin_lock_irq(&nacl->nacl_sess_lock);
1735 se_sess = nacl->nacl_sess;
1737 spin_unlock_irq(&nacl->nacl_sess_lock);
1742 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1744 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1745 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1747 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1748 spin_unlock_irq(&nacl->nacl_sess_lock);
1751 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1753 CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1754 scsi_att_intr_port_group);
1756 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1757 &target_stat_scsi_att_intr_port_inst.attr,
1758 &target_stat_scsi_att_intr_port_dev.attr,
1759 &target_stat_scsi_att_intr_port_port.attr,
1760 &target_stat_scsi_att_intr_port_indx.attr,
1761 &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1762 &target_stat_scsi_att_intr_port_port_ident.attr,
1766 static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1767 .show_attribute = target_stat_scsi_att_intr_port_attr_show,
1768 .store_attribute = target_stat_scsi_att_intr_port_attr_store,
1771 static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1772 .ct_item_ops = &target_stat_scsi_att_intr_port_attrib_ops,
1773 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1774 .ct_owner = THIS_MODULE,
1778 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1779 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1781 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1783 struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1785 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1786 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1787 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1788 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1790 ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1791 ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1792 ml_stat_grp->default_groups[2] = NULL;