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
;