1 /*******************************************************************************
2 * Filename: target_core_stat.c
4 * Modern ConfigFS group context specific statistics based on original
5 * target_core_mib.c code
7 * (c) Copyright 2006-2013 Datera, Inc.
9 * Nicholas A. Bellinger <nab@linux-iscsi.org>
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.
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.
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.
25 ******************************************************************************/
27 #include <linux/kernel.h>
28 #include <linux/module.h>
29 #include <linux/delay.h>
30 #include <linux/timer.h>
31 #include <linux/string.h>
32 #include <linux/utsname.h>
33 #include <linux/proc_fs.h>
34 #include <linux/seq_file.h>
35 #include <linux/configfs.h>
37 #include <target/target_core_base.h>
38 #include <target/target_core_backend.h>
39 #include <target/target_core_fabric.h>
40 #include <target/target_core_configfs.h>
41 #include <target/configfs_macros.h>
43 #include "target_core_internal.h"
45 #ifndef INITIAL_JIFFIES
46 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
50 #define ISPRINT(a) ((a >= ' ') && (a <= '~'))
52 #define SCSI_LU_INDEX 1
59 CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
60 #define DEV_STAT_SCSI_DEV_ATTR(_name, _mode) \
61 static struct target_stat_scsi_dev_attribute \
62 target_stat_scsi_dev_##_name = \
63 __CONFIGFS_EATTR(_name, _mode, \
64 target_stat_scsi_dev_show_attr_##_name, \
65 target_stat_scsi_dev_store_attr_##_name);
67 #define DEV_STAT_SCSI_DEV_ATTR_RO(_name) \
68 static struct target_stat_scsi_dev_attribute \
69 target_stat_scsi_dev_##_name = \
70 __CONFIGFS_EATTR_RO(_name, \
71 target_stat_scsi_dev_show_attr_##_name);
73 static ssize_t target_stat_scsi_dev_show_attr_inst(
74 struct se_dev_stat_grps *sgrps, char *page)
76 struct se_device *dev =
77 container_of(sgrps, struct se_device, dev_stat_grps);
78 struct se_hba *hba = dev->se_hba;
80 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
82 DEV_STAT_SCSI_DEV_ATTR_RO(inst);
84 static ssize_t target_stat_scsi_dev_show_attr_indx(
85 struct se_dev_stat_grps *sgrps, char *page)
87 struct se_device *dev =
88 container_of(sgrps, struct se_device, dev_stat_grps);
90 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
92 DEV_STAT_SCSI_DEV_ATTR_RO(indx);
94 static ssize_t target_stat_scsi_dev_show_attr_role(
95 struct se_dev_stat_grps *sgrps, char *page)
97 return snprintf(page, PAGE_SIZE, "Target\n");
99 DEV_STAT_SCSI_DEV_ATTR_RO(role);
101 static ssize_t target_stat_scsi_dev_show_attr_ports(
102 struct se_dev_stat_grps *sgrps, char *page)
104 struct se_device *dev =
105 container_of(sgrps, struct se_device, dev_stat_grps);
107 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
109 DEV_STAT_SCSI_DEV_ATTR_RO(ports);
111 CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
113 static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
114 &target_stat_scsi_dev_inst.attr,
115 &target_stat_scsi_dev_indx.attr,
116 &target_stat_scsi_dev_role.attr,
117 &target_stat_scsi_dev_ports.attr,
121 static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
122 .show_attribute = target_stat_scsi_dev_attr_show,
123 .store_attribute = target_stat_scsi_dev_attr_store,
126 static struct config_item_type target_stat_scsi_dev_cit = {
127 .ct_item_ops = &target_stat_scsi_dev_attrib_ops,
128 .ct_attrs = target_stat_scsi_dev_attrs,
129 .ct_owner = THIS_MODULE,
133 * SCSI Target Device Table
136 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
137 #define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode) \
138 static struct target_stat_scsi_tgt_dev_attribute \
139 target_stat_scsi_tgt_dev_##_name = \
140 __CONFIGFS_EATTR(_name, _mode, \
141 target_stat_scsi_tgt_dev_show_attr_##_name, \
142 target_stat_scsi_tgt_dev_store_attr_##_name);
144 #define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name) \
145 static struct target_stat_scsi_tgt_dev_attribute \
146 target_stat_scsi_tgt_dev_##_name = \
147 __CONFIGFS_EATTR_RO(_name, \
148 target_stat_scsi_tgt_dev_show_attr_##_name);
150 static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
151 struct se_dev_stat_grps *sgrps, char *page)
153 struct se_device *dev =
154 container_of(sgrps, struct se_device, dev_stat_grps);
155 struct se_hba *hba = dev->se_hba;
157 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
159 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
161 static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
162 struct se_dev_stat_grps *sgrps, char *page)
164 struct se_device *dev =
165 container_of(sgrps, struct se_device, dev_stat_grps);
167 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
169 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
171 static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
172 struct se_dev_stat_grps *sgrps, char *page)
174 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
176 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
178 static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
179 struct se_dev_stat_grps *sgrps, char *page)
181 struct se_device *dev =
182 container_of(sgrps, struct se_device, dev_stat_grps);
184 if (dev->export_count)
185 return snprintf(page, PAGE_SIZE, "activated");
187 return snprintf(page, PAGE_SIZE, "deactivated");
189 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
191 static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
192 struct se_dev_stat_grps *sgrps, char *page)
194 struct se_device *dev =
195 container_of(sgrps, struct se_device, dev_stat_grps);
196 int non_accessible_lus;
198 if (dev->export_count)
199 non_accessible_lus = 0;
201 non_accessible_lus = 1;
203 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
205 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
207 static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
208 struct se_dev_stat_grps *sgrps, char *page)
210 struct se_device *dev =
211 container_of(sgrps, struct se_device, dev_stat_grps);
213 return snprintf(page, PAGE_SIZE, "%lu\n",
214 atomic_long_read(&dev->num_resets));
216 DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
219 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
221 static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
222 &target_stat_scsi_tgt_dev_inst.attr,
223 &target_stat_scsi_tgt_dev_indx.attr,
224 &target_stat_scsi_tgt_dev_num_lus.attr,
225 &target_stat_scsi_tgt_dev_status.attr,
226 &target_stat_scsi_tgt_dev_non_access_lus.attr,
227 &target_stat_scsi_tgt_dev_resets.attr,
231 static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
232 .show_attribute = target_stat_scsi_tgt_dev_attr_show,
233 .store_attribute = target_stat_scsi_tgt_dev_attr_store,
236 static struct config_item_type target_stat_scsi_tgt_dev_cit = {
237 .ct_item_ops = &target_stat_scsi_tgt_dev_attrib_ops,
238 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
239 .ct_owner = THIS_MODULE,
243 * SCSI Logical Unit Table
246 CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
247 #define DEV_STAT_SCSI_LU_ATTR(_name, _mode) \
248 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
249 __CONFIGFS_EATTR(_name, _mode, \
250 target_stat_scsi_lu_show_attr_##_name, \
251 target_stat_scsi_lu_store_attr_##_name);
253 #define DEV_STAT_SCSI_LU_ATTR_RO(_name) \
254 static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
255 __CONFIGFS_EATTR_RO(_name, \
256 target_stat_scsi_lu_show_attr_##_name);
258 static ssize_t target_stat_scsi_lu_show_attr_inst(
259 struct se_dev_stat_grps *sgrps, char *page)
261 struct se_device *dev =
262 container_of(sgrps, struct se_device, dev_stat_grps);
263 struct se_hba *hba = dev->se_hba;
265 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
267 DEV_STAT_SCSI_LU_ATTR_RO(inst);
269 static ssize_t target_stat_scsi_lu_show_attr_dev(
270 struct se_dev_stat_grps *sgrps, char *page)
272 struct se_device *dev =
273 container_of(sgrps, struct se_device, dev_stat_grps);
275 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
277 DEV_STAT_SCSI_LU_ATTR_RO(dev);
279 static ssize_t target_stat_scsi_lu_show_attr_indx(
280 struct se_dev_stat_grps *sgrps, char *page)
282 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
284 DEV_STAT_SCSI_LU_ATTR_RO(indx);
286 static ssize_t target_stat_scsi_lu_show_attr_lun(
287 struct se_dev_stat_grps *sgrps, char *page)
289 /* FIXME: scsiLuDefaultLun */
290 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
292 DEV_STAT_SCSI_LU_ATTR_RO(lun);
294 static ssize_t target_stat_scsi_lu_show_attr_lu_name(
295 struct se_dev_stat_grps *sgrps, char *page)
297 struct se_device *dev =
298 container_of(sgrps, struct se_device, dev_stat_grps);
301 return snprintf(page, PAGE_SIZE, "%s\n",
302 (strlen(dev->t10_wwn.unit_serial)) ?
303 dev->t10_wwn.unit_serial : "None");
305 DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
307 static ssize_t target_stat_scsi_lu_show_attr_vend(
308 struct se_dev_stat_grps *sgrps, char *page)
310 struct se_device *dev =
311 container_of(sgrps, struct se_device, dev_stat_grps);
313 char str[sizeof(dev->t10_wwn.vendor)+1];
316 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
317 str[i] = ISPRINT(dev->t10_wwn.vendor[i]) ?
318 dev->t10_wwn.vendor[i] : ' ';
320 return snprintf(page, PAGE_SIZE, "%s\n", str);
322 DEV_STAT_SCSI_LU_ATTR_RO(vend);
324 static ssize_t target_stat_scsi_lu_show_attr_prod(
325 struct se_dev_stat_grps *sgrps, char *page)
327 struct se_device *dev =
328 container_of(sgrps, struct se_device, dev_stat_grps);
330 char str[sizeof(dev->t10_wwn.model)+1];
332 /* scsiLuProductId */
333 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
334 str[i] = ISPRINT(dev->t10_wwn.model[i]) ?
335 dev->t10_wwn.model[i] : ' ';
337 return snprintf(page, PAGE_SIZE, "%s\n", str);
339 DEV_STAT_SCSI_LU_ATTR_RO(prod);
341 static ssize_t target_stat_scsi_lu_show_attr_rev(
342 struct se_dev_stat_grps *sgrps, char *page)
344 struct se_device *dev =
345 container_of(sgrps, struct se_device, dev_stat_grps);
347 char str[sizeof(dev->t10_wwn.revision)+1];
349 /* scsiLuRevisionId */
350 for (i = 0; i < sizeof(dev->t10_wwn.revision); i++)
351 str[i] = ISPRINT(dev->t10_wwn.revision[i]) ?
352 dev->t10_wwn.revision[i] : ' ';
354 return snprintf(page, PAGE_SIZE, "%s\n", str);
356 DEV_STAT_SCSI_LU_ATTR_RO(rev);
358 static ssize_t target_stat_scsi_lu_show_attr_dev_type(
359 struct se_dev_stat_grps *sgrps, char *page)
361 struct se_device *dev =
362 container_of(sgrps, struct se_device, dev_stat_grps);
364 /* scsiLuPeripheralType */
365 return snprintf(page, PAGE_SIZE, "%u\n",
366 dev->transport->get_device_type(dev));
368 DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
370 static ssize_t target_stat_scsi_lu_show_attr_status(
371 struct se_dev_stat_grps *sgrps, char *page)
373 struct se_device *dev =
374 container_of(sgrps, struct se_device, dev_stat_grps);
377 return snprintf(page, PAGE_SIZE, "%s\n",
378 (dev->export_count) ? "available" : "notavailable");
380 DEV_STAT_SCSI_LU_ATTR_RO(status);
382 static ssize_t target_stat_scsi_lu_show_attr_state_bit(
383 struct se_dev_stat_grps *sgrps, char *page)
386 return snprintf(page, PAGE_SIZE, "exposed\n");
388 DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
390 static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
391 struct se_dev_stat_grps *sgrps, char *page)
393 struct se_device *dev =
394 container_of(sgrps, struct se_device, dev_stat_grps);
396 /* scsiLuNumCommands */
397 return snprintf(page, PAGE_SIZE, "%lu\n",
398 atomic_long_read(&dev->num_cmds));
400 DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
402 static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
403 struct se_dev_stat_grps *sgrps, char *page)
405 struct se_device *dev =
406 container_of(sgrps, struct se_device, dev_stat_grps);
408 /* scsiLuReadMegaBytes */
409 return snprintf(page, PAGE_SIZE, "%lu\n",
410 atomic_long_read(&dev->read_bytes) >> 20);
412 DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
414 static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
415 struct se_dev_stat_grps *sgrps, char *page)
417 struct se_device *dev =
418 container_of(sgrps, struct se_device, dev_stat_grps);
420 /* scsiLuWrittenMegaBytes */
421 return snprintf(page, PAGE_SIZE, "%lu\n",
422 atomic_long_read(&dev->write_bytes) >> 20);
424 DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
426 static ssize_t target_stat_scsi_lu_show_attr_resets(
427 struct se_dev_stat_grps *sgrps, char *page)
429 struct se_device *dev =
430 container_of(sgrps, struct se_device, dev_stat_grps);
433 return snprintf(page, PAGE_SIZE, "%lu\n", atomic_long_read(&dev->num_resets));
435 DEV_STAT_SCSI_LU_ATTR_RO(resets);
437 static ssize_t target_stat_scsi_lu_show_attr_full_stat(
438 struct se_dev_stat_grps *sgrps, char *page)
440 /* FIXME: scsiLuOutTaskSetFullStatus */
441 return snprintf(page, PAGE_SIZE, "%u\n", 0);
443 DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
445 static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
446 struct se_dev_stat_grps *sgrps, char *page)
448 /* FIXME: scsiLuHSInCommands */
449 return snprintf(page, PAGE_SIZE, "%u\n", 0);
451 DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
453 static ssize_t target_stat_scsi_lu_show_attr_creation_time(
454 struct se_dev_stat_grps *sgrps, char *page)
456 struct se_device *dev =
457 container_of(sgrps, struct se_device, dev_stat_grps);
459 /* scsiLuCreationTime */
460 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
461 INITIAL_JIFFIES) * 100 / HZ));
463 DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
465 CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
467 static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
468 &target_stat_scsi_lu_inst.attr,
469 &target_stat_scsi_lu_dev.attr,
470 &target_stat_scsi_lu_indx.attr,
471 &target_stat_scsi_lu_lun.attr,
472 &target_stat_scsi_lu_lu_name.attr,
473 &target_stat_scsi_lu_vend.attr,
474 &target_stat_scsi_lu_prod.attr,
475 &target_stat_scsi_lu_rev.attr,
476 &target_stat_scsi_lu_dev_type.attr,
477 &target_stat_scsi_lu_status.attr,
478 &target_stat_scsi_lu_state_bit.attr,
479 &target_stat_scsi_lu_num_cmds.attr,
480 &target_stat_scsi_lu_read_mbytes.attr,
481 &target_stat_scsi_lu_write_mbytes.attr,
482 &target_stat_scsi_lu_resets.attr,
483 &target_stat_scsi_lu_full_stat.attr,
484 &target_stat_scsi_lu_hs_num_cmds.attr,
485 &target_stat_scsi_lu_creation_time.attr,
489 static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
490 .show_attribute = target_stat_scsi_lu_attr_show,
491 .store_attribute = target_stat_scsi_lu_attr_store,
494 static struct config_item_type target_stat_scsi_lu_cit = {
495 .ct_item_ops = &target_stat_scsi_lu_attrib_ops,
496 .ct_attrs = target_stat_scsi_lu_attrs,
497 .ct_owner = THIS_MODULE,
501 * Called from target_core_configfs.c:target_core_make_subdev() to setup
502 * the target statistics groups + configfs CITs located in target_core_stat.c
504 void target_stat_setup_dev_default_groups(struct se_device *dev)
506 struct config_group *dev_stat_grp = &dev->dev_stat_grps.stat_group;
508 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
509 "scsi_dev", &target_stat_scsi_dev_cit);
510 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
511 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
512 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
513 "scsi_lu", &target_stat_scsi_lu_cit);
515 dev_stat_grp->default_groups[0] = &dev->dev_stat_grps.scsi_dev_group;
516 dev_stat_grp->default_groups[1] = &dev->dev_stat_grps.scsi_tgt_dev_group;
517 dev_stat_grp->default_groups[2] = &dev->dev_stat_grps.scsi_lu_group;
518 dev_stat_grp->default_groups[3] = NULL;
525 CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
526 #define DEV_STAT_SCSI_PORT_ATTR(_name, _mode) \
527 static struct target_stat_scsi_port_attribute \
528 target_stat_scsi_port_##_name = \
529 __CONFIGFS_EATTR(_name, _mode, \
530 target_stat_scsi_port_show_attr_##_name, \
531 target_stat_scsi_port_store_attr_##_name);
533 #define DEV_STAT_SCSI_PORT_ATTR_RO(_name) \
534 static struct target_stat_scsi_port_attribute \
535 target_stat_scsi_port_##_name = \
536 __CONFIGFS_EATTR_RO(_name, \
537 target_stat_scsi_port_show_attr_##_name);
539 static ssize_t target_stat_scsi_port_show_attr_inst(
540 struct se_port_stat_grps *pgrps, char *page)
542 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
544 struct se_device *dev = lun->lun_se_dev;
548 spin_lock(&lun->lun_sep_lock);
551 spin_unlock(&lun->lun_sep_lock);
555 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
556 spin_unlock(&lun->lun_sep_lock);
559 DEV_STAT_SCSI_PORT_ATTR_RO(inst);
561 static ssize_t target_stat_scsi_port_show_attr_dev(
562 struct se_port_stat_grps *pgrps, char *page)
564 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
566 struct se_device *dev = lun->lun_se_dev;
569 spin_lock(&lun->lun_sep_lock);
572 spin_unlock(&lun->lun_sep_lock);
575 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
576 spin_unlock(&lun->lun_sep_lock);
579 DEV_STAT_SCSI_PORT_ATTR_RO(dev);
581 static ssize_t target_stat_scsi_port_show_attr_indx(
582 struct se_port_stat_grps *pgrps, char *page)
584 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
588 spin_lock(&lun->lun_sep_lock);
591 spin_unlock(&lun->lun_sep_lock);
594 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
595 spin_unlock(&lun->lun_sep_lock);
598 DEV_STAT_SCSI_PORT_ATTR_RO(indx);
600 static ssize_t target_stat_scsi_port_show_attr_role(
601 struct se_port_stat_grps *pgrps, char *page)
603 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
604 struct se_device *dev = lun->lun_se_dev;
611 spin_lock(&lun->lun_sep_lock);
614 spin_unlock(&lun->lun_sep_lock);
617 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
618 spin_unlock(&lun->lun_sep_lock);
621 DEV_STAT_SCSI_PORT_ATTR_RO(role);
623 static ssize_t target_stat_scsi_port_show_attr_busy_count(
624 struct se_port_stat_grps *pgrps, char *page)
626 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
630 spin_lock(&lun->lun_sep_lock);
633 spin_unlock(&lun->lun_sep_lock);
636 /* FIXME: scsiPortBusyStatuses */
637 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
638 spin_unlock(&lun->lun_sep_lock);
641 DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
643 CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
645 static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
646 &target_stat_scsi_port_inst.attr,
647 &target_stat_scsi_port_dev.attr,
648 &target_stat_scsi_port_indx.attr,
649 &target_stat_scsi_port_role.attr,
650 &target_stat_scsi_port_busy_count.attr,
654 static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
655 .show_attribute = target_stat_scsi_port_attr_show,
656 .store_attribute = target_stat_scsi_port_attr_store,
659 static struct config_item_type target_stat_scsi_port_cit = {
660 .ct_item_ops = &target_stat_scsi_port_attrib_ops,
661 .ct_attrs = target_stat_scsi_port_attrs,
662 .ct_owner = THIS_MODULE,
666 * SCSI Target Port Table
668 CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
669 #define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode) \
670 static struct target_stat_scsi_tgt_port_attribute \
671 target_stat_scsi_tgt_port_##_name = \
672 __CONFIGFS_EATTR(_name, _mode, \
673 target_stat_scsi_tgt_port_show_attr_##_name, \
674 target_stat_scsi_tgt_port_store_attr_##_name);
676 #define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name) \
677 static struct target_stat_scsi_tgt_port_attribute \
678 target_stat_scsi_tgt_port_##_name = \
679 __CONFIGFS_EATTR_RO(_name, \
680 target_stat_scsi_tgt_port_show_attr_##_name);
682 static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
683 struct se_port_stat_grps *pgrps, char *page)
685 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
686 struct se_device *dev = lun->lun_se_dev;
691 spin_lock(&lun->lun_sep_lock);
694 spin_unlock(&lun->lun_sep_lock);
698 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
699 spin_unlock(&lun->lun_sep_lock);
702 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
704 static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
705 struct se_port_stat_grps *pgrps, char *page)
707 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
708 struct se_device *dev = lun->lun_se_dev;
712 spin_lock(&lun->lun_sep_lock);
715 spin_unlock(&lun->lun_sep_lock);
718 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
719 spin_unlock(&lun->lun_sep_lock);
722 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
724 static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
725 struct se_port_stat_grps *pgrps, char *page)
727 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
731 spin_lock(&lun->lun_sep_lock);
734 spin_unlock(&lun->lun_sep_lock);
737 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
738 spin_unlock(&lun->lun_sep_lock);
741 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
743 static ssize_t target_stat_scsi_tgt_port_show_attr_name(
744 struct se_port_stat_grps *pgrps, char *page)
746 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
748 struct se_portal_group *tpg;
751 spin_lock(&lun->lun_sep_lock);
754 spin_unlock(&lun->lun_sep_lock);
759 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
760 tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
761 spin_unlock(&lun->lun_sep_lock);
764 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
766 static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
767 struct se_port_stat_grps *pgrps, char *page)
769 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
771 struct se_portal_group *tpg;
774 spin_lock(&lun->lun_sep_lock);
777 spin_unlock(&lun->lun_sep_lock);
782 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
783 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
784 tpg->se_tpg_tfo->tpg_get_tag(tpg));
785 spin_unlock(&lun->lun_sep_lock);
788 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
790 static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
791 struct se_port_stat_grps *pgrps, char *page)
793 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
797 spin_lock(&lun->lun_sep_lock);
800 spin_unlock(&lun->lun_sep_lock);
804 ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
805 spin_unlock(&lun->lun_sep_lock);
808 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
810 static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
811 struct se_port_stat_grps *pgrps, char *page)
813 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
817 spin_lock(&lun->lun_sep_lock);
820 spin_unlock(&lun->lun_sep_lock);
824 ret = snprintf(page, PAGE_SIZE, "%u\n",
825 (u32)(sep->sep_stats.rx_data_octets >> 20));
826 spin_unlock(&lun->lun_sep_lock);
829 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
831 static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
832 struct se_port_stat_grps *pgrps, char *page)
834 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
838 spin_lock(&lun->lun_sep_lock);
841 spin_unlock(&lun->lun_sep_lock);
845 ret = snprintf(page, PAGE_SIZE, "%u\n",
846 (u32)(sep->sep_stats.tx_data_octets >> 20));
847 spin_unlock(&lun->lun_sep_lock);
850 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
852 static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
853 struct se_port_stat_grps *pgrps, char *page)
855 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
859 spin_lock(&lun->lun_sep_lock);
862 spin_unlock(&lun->lun_sep_lock);
866 /* FIXME: scsiTgtPortHsInCommands */
867 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
868 spin_unlock(&lun->lun_sep_lock);
871 DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
873 CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
874 scsi_tgt_port_group);
876 static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
877 &target_stat_scsi_tgt_port_inst.attr,
878 &target_stat_scsi_tgt_port_dev.attr,
879 &target_stat_scsi_tgt_port_indx.attr,
880 &target_stat_scsi_tgt_port_name.attr,
881 &target_stat_scsi_tgt_port_port_index.attr,
882 &target_stat_scsi_tgt_port_in_cmds.attr,
883 &target_stat_scsi_tgt_port_write_mbytes.attr,
884 &target_stat_scsi_tgt_port_read_mbytes.attr,
885 &target_stat_scsi_tgt_port_hs_in_cmds.attr,
889 static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
890 .show_attribute = target_stat_scsi_tgt_port_attr_show,
891 .store_attribute = target_stat_scsi_tgt_port_attr_store,
894 static struct config_item_type target_stat_scsi_tgt_port_cit = {
895 .ct_item_ops = &target_stat_scsi_tgt_port_attrib_ops,
896 .ct_attrs = target_stat_scsi_tgt_port_attrs,
897 .ct_owner = THIS_MODULE,
901 * SCSI Transport Table
904 CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
905 #define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode) \
906 static struct target_stat_scsi_transport_attribute \
907 target_stat_scsi_transport_##_name = \
908 __CONFIGFS_EATTR(_name, _mode, \
909 target_stat_scsi_transport_show_attr_##_name, \
910 target_stat_scsi_transport_store_attr_##_name);
912 #define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name) \
913 static struct target_stat_scsi_transport_attribute \
914 target_stat_scsi_transport_##_name = \
915 __CONFIGFS_EATTR_RO(_name, \
916 target_stat_scsi_transport_show_attr_##_name);
918 static ssize_t target_stat_scsi_transport_show_attr_inst(
919 struct se_port_stat_grps *pgrps, char *page)
921 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
922 struct se_device *dev = lun->lun_se_dev;
927 spin_lock(&lun->lun_sep_lock);
930 spin_unlock(&lun->lun_sep_lock);
935 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
936 spin_unlock(&lun->lun_sep_lock);
939 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
941 static ssize_t target_stat_scsi_transport_show_attr_device(
942 struct se_port_stat_grps *pgrps, char *page)
944 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
946 struct se_portal_group *tpg;
949 spin_lock(&lun->lun_sep_lock);
952 spin_unlock(&lun->lun_sep_lock);
956 /* scsiTransportType */
957 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
958 tpg->se_tpg_tfo->get_fabric_name());
959 spin_unlock(&lun->lun_sep_lock);
962 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
964 static ssize_t target_stat_scsi_transport_show_attr_indx(
965 struct se_port_stat_grps *pgrps, char *page)
967 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
969 struct se_portal_group *tpg;
972 spin_lock(&lun->lun_sep_lock);
975 spin_unlock(&lun->lun_sep_lock);
979 ret = snprintf(page, PAGE_SIZE, "%u\n",
980 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
981 spin_unlock(&lun->lun_sep_lock);
984 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
986 static ssize_t target_stat_scsi_transport_show_attr_dev_name(
987 struct se_port_stat_grps *pgrps, char *page)
989 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
990 struct se_device *dev = lun->lun_se_dev;
992 struct se_portal_group *tpg;
996 spin_lock(&lun->lun_sep_lock);
999 spin_unlock(&lun->lun_sep_lock);
1003 wwn = &dev->t10_wwn;
1004 /* scsiTransportDevName */
1005 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1006 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1007 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
1009 spin_unlock(&lun->lun_sep_lock);
1012 DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1014 CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1015 scsi_transport_group);
1017 static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1018 &target_stat_scsi_transport_inst.attr,
1019 &target_stat_scsi_transport_device.attr,
1020 &target_stat_scsi_transport_indx.attr,
1021 &target_stat_scsi_transport_dev_name.attr,
1025 static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1026 .show_attribute = target_stat_scsi_transport_attr_show,
1027 .store_attribute = target_stat_scsi_transport_attr_store,
1030 static struct config_item_type target_stat_scsi_transport_cit = {
1031 .ct_item_ops = &target_stat_scsi_transport_attrib_ops,
1032 .ct_attrs = target_stat_scsi_transport_attrs,
1033 .ct_owner = THIS_MODULE,
1037 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1038 * the target port statistics groups + configfs CITs located in target_core_stat.c
1040 void target_stat_setup_port_default_groups(struct se_lun *lun)
1042 struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1044 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1045 "scsi_port", &target_stat_scsi_port_cit);
1046 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1047 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1048 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1049 "scsi_transport", &target_stat_scsi_transport_cit);
1051 port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1052 port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1053 port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1054 port_stat_grp->default_groups[3] = NULL;
1058 * SCSI Authorized Initiator Table
1061 CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1062 #define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode) \
1063 static struct target_stat_scsi_auth_intr_attribute \
1064 target_stat_scsi_auth_intr_##_name = \
1065 __CONFIGFS_EATTR(_name, _mode, \
1066 target_stat_scsi_auth_intr_show_attr_##_name, \
1067 target_stat_scsi_auth_intr_store_attr_##_name);
1069 #define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name) \
1070 static struct target_stat_scsi_auth_intr_attribute \
1071 target_stat_scsi_auth_intr_##_name = \
1072 __CONFIGFS_EATTR_RO(_name, \
1073 target_stat_scsi_auth_intr_show_attr_##_name);
1075 static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1076 struct se_ml_stat_grps *lgrps, char *page)
1078 struct se_lun_acl *lacl = container_of(lgrps,
1079 struct se_lun_acl, ml_stat_grps);
1080 struct se_node_acl *nacl = lacl->se_lun_nacl;
1081 struct se_dev_entry *deve;
1082 struct se_portal_group *tpg;
1085 spin_lock_irq(&nacl->device_list_lock);
1086 deve = nacl->device_list[lacl->mapped_lun];
1087 if (!deve->se_lun || !deve->se_lun_acl) {
1088 spin_unlock_irq(&nacl->device_list_lock);
1093 ret = snprintf(page, PAGE_SIZE, "%u\n",
1094 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1095 spin_unlock_irq(&nacl->device_list_lock);
1098 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1100 static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1101 struct se_ml_stat_grps *lgrps, char *page)
1103 struct se_lun_acl *lacl = container_of(lgrps,
1104 struct se_lun_acl, ml_stat_grps);
1105 struct se_node_acl *nacl = lacl->se_lun_nacl;
1106 struct se_dev_entry *deve;
1110 spin_lock_irq(&nacl->device_list_lock);
1111 deve = nacl->device_list[lacl->mapped_lun];
1112 if (!deve->se_lun || !deve->se_lun_acl) {
1113 spin_unlock_irq(&nacl->device_list_lock);
1117 /* scsiDeviceIndex */
1118 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1119 spin_unlock_irq(&nacl->device_list_lock);
1122 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1124 static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1125 struct se_ml_stat_grps *lgrps, char *page)
1127 struct se_lun_acl *lacl = container_of(lgrps,
1128 struct se_lun_acl, ml_stat_grps);
1129 struct se_node_acl *nacl = lacl->se_lun_nacl;
1130 struct se_dev_entry *deve;
1131 struct se_portal_group *tpg;
1134 spin_lock_irq(&nacl->device_list_lock);
1135 deve = nacl->device_list[lacl->mapped_lun];
1136 if (!deve->se_lun || !deve->se_lun_acl) {
1137 spin_unlock_irq(&nacl->device_list_lock);
1141 /* scsiAuthIntrTgtPortIndex */
1142 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1143 spin_unlock_irq(&nacl->device_list_lock);
1146 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1148 static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1149 struct se_ml_stat_grps *lgrps, char *page)
1151 struct se_lun_acl *lacl = container_of(lgrps,
1152 struct se_lun_acl, ml_stat_grps);
1153 struct se_node_acl *nacl = lacl->se_lun_nacl;
1154 struct se_dev_entry *deve;
1157 spin_lock_irq(&nacl->device_list_lock);
1158 deve = nacl->device_list[lacl->mapped_lun];
1159 if (!deve->se_lun || !deve->se_lun_acl) {
1160 spin_unlock_irq(&nacl->device_list_lock);
1163 /* scsiAuthIntrIndex */
1164 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1165 spin_unlock_irq(&nacl->device_list_lock);
1168 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1170 static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1171 struct se_ml_stat_grps *lgrps, char *page)
1173 struct se_lun_acl *lacl = container_of(lgrps,
1174 struct se_lun_acl, ml_stat_grps);
1175 struct se_node_acl *nacl = lacl->se_lun_nacl;
1176 struct se_dev_entry *deve;
1179 spin_lock_irq(&nacl->device_list_lock);
1180 deve = nacl->device_list[lacl->mapped_lun];
1181 if (!deve->se_lun || !deve->se_lun_acl) {
1182 spin_unlock_irq(&nacl->device_list_lock);
1185 /* scsiAuthIntrDevOrPort */
1186 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1187 spin_unlock_irq(&nacl->device_list_lock);
1190 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1192 static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1193 struct se_ml_stat_grps *lgrps, char *page)
1195 struct se_lun_acl *lacl = container_of(lgrps,
1196 struct se_lun_acl, ml_stat_grps);
1197 struct se_node_acl *nacl = lacl->se_lun_nacl;
1198 struct se_dev_entry *deve;
1201 spin_lock_irq(&nacl->device_list_lock);
1202 deve = nacl->device_list[lacl->mapped_lun];
1203 if (!deve->se_lun || !deve->se_lun_acl) {
1204 spin_unlock_irq(&nacl->device_list_lock);
1207 /* scsiAuthIntrName */
1208 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1209 spin_unlock_irq(&nacl->device_list_lock);
1212 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1214 static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1215 struct se_ml_stat_grps *lgrps, char *page)
1217 struct se_lun_acl *lacl = container_of(lgrps,
1218 struct se_lun_acl, ml_stat_grps);
1219 struct se_node_acl *nacl = lacl->se_lun_nacl;
1220 struct se_dev_entry *deve;
1223 spin_lock_irq(&nacl->device_list_lock);
1224 deve = nacl->device_list[lacl->mapped_lun];
1225 if (!deve->se_lun || !deve->se_lun_acl) {
1226 spin_unlock_irq(&nacl->device_list_lock);
1229 /* FIXME: scsiAuthIntrLunMapIndex */
1230 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1231 spin_unlock_irq(&nacl->device_list_lock);
1234 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1236 static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
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;
1245 spin_lock_irq(&nacl->device_list_lock);
1246 deve = nacl->device_list[lacl->mapped_lun];
1247 if (!deve->se_lun || !deve->se_lun_acl) {
1248 spin_unlock_irq(&nacl->device_list_lock);
1251 /* scsiAuthIntrAttachedTimes */
1252 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1253 spin_unlock_irq(&nacl->device_list_lock);
1256 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1258 static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1259 struct se_ml_stat_grps *lgrps, char *page)
1261 struct se_lun_acl *lacl = container_of(lgrps,
1262 struct se_lun_acl, ml_stat_grps);
1263 struct se_node_acl *nacl = lacl->se_lun_nacl;
1264 struct se_dev_entry *deve;
1267 spin_lock_irq(&nacl->device_list_lock);
1268 deve = nacl->device_list[lacl->mapped_lun];
1269 if (!deve->se_lun || !deve->se_lun_acl) {
1270 spin_unlock_irq(&nacl->device_list_lock);
1273 /* scsiAuthIntrOutCommands */
1274 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1275 spin_unlock_irq(&nacl->device_list_lock);
1278 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1280 static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1281 struct se_ml_stat_grps *lgrps, char *page)
1283 struct se_lun_acl *lacl = container_of(lgrps,
1284 struct se_lun_acl, ml_stat_grps);
1285 struct se_node_acl *nacl = lacl->se_lun_nacl;
1286 struct se_dev_entry *deve;
1289 spin_lock_irq(&nacl->device_list_lock);
1290 deve = nacl->device_list[lacl->mapped_lun];
1291 if (!deve->se_lun || !deve->se_lun_acl) {
1292 spin_unlock_irq(&nacl->device_list_lock);
1295 /* scsiAuthIntrReadMegaBytes */
1296 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1297 spin_unlock_irq(&nacl->device_list_lock);
1300 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1302 static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1303 struct se_ml_stat_grps *lgrps, char *page)
1305 struct se_lun_acl *lacl = container_of(lgrps,
1306 struct se_lun_acl, ml_stat_grps);
1307 struct se_node_acl *nacl = lacl->se_lun_nacl;
1308 struct se_dev_entry *deve;
1311 spin_lock_irq(&nacl->device_list_lock);
1312 deve = nacl->device_list[lacl->mapped_lun];
1313 if (!deve->se_lun || !deve->se_lun_acl) {
1314 spin_unlock_irq(&nacl->device_list_lock);
1317 /* scsiAuthIntrWrittenMegaBytes */
1318 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1319 spin_unlock_irq(&nacl->device_list_lock);
1322 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1324 static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1325 struct se_ml_stat_grps *lgrps, char *page)
1327 struct se_lun_acl *lacl = container_of(lgrps,
1328 struct se_lun_acl, ml_stat_grps);
1329 struct se_node_acl *nacl = lacl->se_lun_nacl;
1330 struct se_dev_entry *deve;
1333 spin_lock_irq(&nacl->device_list_lock);
1334 deve = nacl->device_list[lacl->mapped_lun];
1335 if (!deve->se_lun || !deve->se_lun_acl) {
1336 spin_unlock_irq(&nacl->device_list_lock);
1339 /* FIXME: scsiAuthIntrHSOutCommands */
1340 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1341 spin_unlock_irq(&nacl->device_list_lock);
1344 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1346 static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1347 struct se_ml_stat_grps *lgrps, char *page)
1349 struct se_lun_acl *lacl = container_of(lgrps,
1350 struct se_lun_acl, ml_stat_grps);
1351 struct se_node_acl *nacl = lacl->se_lun_nacl;
1352 struct se_dev_entry *deve;
1355 spin_lock_irq(&nacl->device_list_lock);
1356 deve = nacl->device_list[lacl->mapped_lun];
1357 if (!deve->se_lun || !deve->se_lun_acl) {
1358 spin_unlock_irq(&nacl->device_list_lock);
1361 /* scsiAuthIntrLastCreation */
1362 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1363 INITIAL_JIFFIES) * 100 / HZ));
1364 spin_unlock_irq(&nacl->device_list_lock);
1367 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1369 static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1370 struct se_ml_stat_grps *lgrps, char *page)
1372 struct se_lun_acl *lacl = container_of(lgrps,
1373 struct se_lun_acl, ml_stat_grps);
1374 struct se_node_acl *nacl = lacl->se_lun_nacl;
1375 struct se_dev_entry *deve;
1378 spin_lock_irq(&nacl->device_list_lock);
1379 deve = nacl->device_list[lacl->mapped_lun];
1380 if (!deve->se_lun || !deve->se_lun_acl) {
1381 spin_unlock_irq(&nacl->device_list_lock);
1384 /* FIXME: scsiAuthIntrRowStatus */
1385 ret = snprintf(page, PAGE_SIZE, "Ready\n");
1386 spin_unlock_irq(&nacl->device_list_lock);
1389 DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1391 CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1392 scsi_auth_intr_group);
1394 static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1395 &target_stat_scsi_auth_intr_inst.attr,
1396 &target_stat_scsi_auth_intr_dev.attr,
1397 &target_stat_scsi_auth_intr_port.attr,
1398 &target_stat_scsi_auth_intr_indx.attr,
1399 &target_stat_scsi_auth_intr_dev_or_port.attr,
1400 &target_stat_scsi_auth_intr_intr_name.attr,
1401 &target_stat_scsi_auth_intr_map_indx.attr,
1402 &target_stat_scsi_auth_intr_att_count.attr,
1403 &target_stat_scsi_auth_intr_num_cmds.attr,
1404 &target_stat_scsi_auth_intr_read_mbytes.attr,
1405 &target_stat_scsi_auth_intr_write_mbytes.attr,
1406 &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1407 &target_stat_scsi_auth_intr_creation_time.attr,
1408 &target_stat_scsi_auth_intr_row_status.attr,
1412 static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1413 .show_attribute = target_stat_scsi_auth_intr_attr_show,
1414 .store_attribute = target_stat_scsi_auth_intr_attr_store,
1417 static struct config_item_type target_stat_scsi_auth_intr_cit = {
1418 .ct_item_ops = &target_stat_scsi_auth_intr_attrib_ops,
1419 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1420 .ct_owner = THIS_MODULE,
1424 * SCSI Attached Initiator Port Table
1427 CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1428 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode) \
1429 static struct target_stat_scsi_att_intr_port_attribute \
1430 target_stat_scsi_att_intr_port_##_name = \
1431 __CONFIGFS_EATTR(_name, _mode, \
1432 target_stat_scsi_att_intr_port_show_attr_##_name, \
1433 target_stat_scsi_att_intr_port_store_attr_##_name);
1435 #define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name) \
1436 static struct target_stat_scsi_att_intr_port_attribute \
1437 target_stat_scsi_att_intr_port_##_name = \
1438 __CONFIGFS_EATTR_RO(_name, \
1439 target_stat_scsi_att_intr_port_show_attr_##_name);
1441 static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
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;
1448 struct se_portal_group *tpg;
1451 spin_lock_irq(&nacl->device_list_lock);
1452 deve = nacl->device_list[lacl->mapped_lun];
1453 if (!deve->se_lun || !deve->se_lun_acl) {
1454 spin_unlock_irq(&nacl->device_list_lock);
1459 ret = snprintf(page, PAGE_SIZE, "%u\n",
1460 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1461 spin_unlock_irq(&nacl->device_list_lock);
1464 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1466 static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1467 struct se_ml_stat_grps *lgrps, char *page)
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;
1476 spin_lock_irq(&nacl->device_list_lock);
1477 deve = nacl->device_list[lacl->mapped_lun];
1478 if (!deve->se_lun || !deve->se_lun_acl) {
1479 spin_unlock_irq(&nacl->device_list_lock);
1483 /* scsiDeviceIndex */
1484 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1485 spin_unlock_irq(&nacl->device_list_lock);
1488 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1490 static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1491 struct se_ml_stat_grps *lgrps, char *page)
1493 struct se_lun_acl *lacl = container_of(lgrps,
1494 struct se_lun_acl, ml_stat_grps);
1495 struct se_node_acl *nacl = lacl->se_lun_nacl;
1496 struct se_dev_entry *deve;
1497 struct se_portal_group *tpg;
1500 spin_lock_irq(&nacl->device_list_lock);
1501 deve = nacl->device_list[lacl->mapped_lun];
1502 if (!deve->se_lun || !deve->se_lun_acl) {
1503 spin_unlock_irq(&nacl->device_list_lock);
1508 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1509 spin_unlock_irq(&nacl->device_list_lock);
1512 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1514 static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1515 struct se_ml_stat_grps *lgrps, char *page)
1517 struct se_lun_acl *lacl = container_of(lgrps,
1518 struct se_lun_acl, ml_stat_grps);
1519 struct se_node_acl *nacl = lacl->se_lun_nacl;
1520 struct se_session *se_sess;
1521 struct se_portal_group *tpg;
1524 spin_lock_irq(&nacl->nacl_sess_lock);
1525 se_sess = nacl->nacl_sess;
1527 spin_unlock_irq(&nacl->nacl_sess_lock);
1532 /* scsiAttIntrPortIndex */
1533 ret = snprintf(page, PAGE_SIZE, "%u\n",
1534 tpg->se_tpg_tfo->sess_get_index(se_sess));
1535 spin_unlock_irq(&nacl->nacl_sess_lock);
1538 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1540 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1541 struct se_ml_stat_grps *lgrps, char *page)
1543 struct se_lun_acl *lacl = container_of(lgrps,
1544 struct se_lun_acl, ml_stat_grps);
1545 struct se_node_acl *nacl = lacl->se_lun_nacl;
1546 struct se_dev_entry *deve;
1549 spin_lock_irq(&nacl->device_list_lock);
1550 deve = nacl->device_list[lacl->mapped_lun];
1551 if (!deve->se_lun || !deve->se_lun_acl) {
1552 spin_unlock_irq(&nacl->device_list_lock);
1555 /* scsiAttIntrPortAuthIntrIdx */
1556 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1557 spin_unlock_irq(&nacl->device_list_lock);
1560 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1562 static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1563 struct se_ml_stat_grps *lgrps, char *page)
1565 struct se_lun_acl *lacl = container_of(lgrps,
1566 struct se_lun_acl, ml_stat_grps);
1567 struct se_node_acl *nacl = lacl->se_lun_nacl;
1568 struct se_session *se_sess;
1569 struct se_portal_group *tpg;
1571 unsigned char buf[64];
1573 spin_lock_irq(&nacl->nacl_sess_lock);
1574 se_sess = nacl->nacl_sess;
1576 spin_unlock_irq(&nacl->nacl_sess_lock);
1581 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1583 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1584 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1586 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1587 spin_unlock_irq(&nacl->nacl_sess_lock);
1590 DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1592 CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1593 scsi_att_intr_port_group);
1595 static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1596 &target_stat_scsi_att_intr_port_inst.attr,
1597 &target_stat_scsi_att_intr_port_dev.attr,
1598 &target_stat_scsi_att_intr_port_port.attr,
1599 &target_stat_scsi_att_intr_port_indx.attr,
1600 &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1601 &target_stat_scsi_att_intr_port_port_ident.attr,
1605 static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1606 .show_attribute = target_stat_scsi_att_intr_port_attr_show,
1607 .store_attribute = target_stat_scsi_att_intr_port_attr_store,
1610 static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1611 .ct_item_ops = &target_stat_scsi_att_intr_port_attrib_ops,
1612 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1613 .ct_owner = THIS_MODULE,
1617 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1618 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1620 void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1622 struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1624 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1625 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1626 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1627 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1629 ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1630 ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1631 ml_stat_grp->default_groups[2] = NULL;