1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/delay.h>
30#include <linux/timer.h>
31#include <linux/string.h>
32#include <linux/utsname.h>
33#include <linux/proc_fs.h>
34#include <linux/seq_file.h>
35#include <linux/blkdev.h>
36#include <linux/configfs.h>
37#include <scsi/scsi.h>
38#include <scsi/scsi_device.h>
39#include <scsi/scsi_host.h>
40
41#include <target/target_core_base.h>
42#include <target/target_core_backend.h>
43#include <target/target_core_fabric.h>
44#include <target/target_core_configfs.h>
45#include <target/configfs_macros.h>
46
47#include "target_core_internal.h"
48
49#ifndef INITIAL_JIFFIES
50#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
51#endif
52
53#define NONE "None"
54#define ISPRINT(a) ((a >= ' ') && (a <= '~'))
55
56#define SCSI_LU_INDEX 1
57#define LU_COUNT 1
58
59
60
61
62
63CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
64#define DEV_STAT_SCSI_DEV_ATTR(_name, _mode) \
65static struct target_stat_scsi_dev_attribute \
66 target_stat_scsi_dev_##_name = \
67 __CONFIGFS_EATTR(_name, _mode, \
68 target_stat_scsi_dev_show_attr_##_name, \
69 target_stat_scsi_dev_store_attr_##_name);
70
71#define DEV_STAT_SCSI_DEV_ATTR_RO(_name) \
72static struct target_stat_scsi_dev_attribute \
73 target_stat_scsi_dev_##_name = \
74 __CONFIGFS_EATTR_RO(_name, \
75 target_stat_scsi_dev_show_attr_##_name);
76
77static ssize_t target_stat_scsi_dev_show_attr_inst(
78 struct se_dev_stat_grps *sgrps, char *page)
79{
80 struct se_device *dev =
81 container_of(sgrps, struct se_device, dev_stat_grps);
82 struct se_hba *hba = dev->se_hba;
83
84 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
85}
86DEV_STAT_SCSI_DEV_ATTR_RO(inst);
87
88static ssize_t target_stat_scsi_dev_show_attr_indx(
89 struct se_dev_stat_grps *sgrps, char *page)
90{
91 struct se_device *dev =
92 container_of(sgrps, struct se_device, dev_stat_grps);
93
94 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
95}
96DEV_STAT_SCSI_DEV_ATTR_RO(indx);
97
98static ssize_t target_stat_scsi_dev_show_attr_role(
99 struct se_dev_stat_grps *sgrps, char *page)
100{
101 return snprintf(page, PAGE_SIZE, "Target\n");
102}
103DEV_STAT_SCSI_DEV_ATTR_RO(role);
104
105static ssize_t target_stat_scsi_dev_show_attr_ports(
106 struct se_dev_stat_grps *sgrps, char *page)
107{
108 struct se_device *dev =
109 container_of(sgrps, struct se_device, dev_stat_grps);
110
111 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
112}
113DEV_STAT_SCSI_DEV_ATTR_RO(ports);
114
115CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
116
117static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
118 &target_stat_scsi_dev_inst.attr,
119 &target_stat_scsi_dev_indx.attr,
120 &target_stat_scsi_dev_role.attr,
121 &target_stat_scsi_dev_ports.attr,
122 NULL,
123};
124
125static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
126 .show_attribute = target_stat_scsi_dev_attr_show,
127 .store_attribute = target_stat_scsi_dev_attr_store,
128};
129
130static struct config_item_type target_stat_scsi_dev_cit = {
131 .ct_item_ops = &target_stat_scsi_dev_attrib_ops,
132 .ct_attrs = target_stat_scsi_dev_attrs,
133 .ct_owner = THIS_MODULE,
134};
135
136
137
138
139
140CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
141#define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode) \
142static struct target_stat_scsi_tgt_dev_attribute \
143 target_stat_scsi_tgt_dev_##_name = \
144 __CONFIGFS_EATTR(_name, _mode, \
145 target_stat_scsi_tgt_dev_show_attr_##_name, \
146 target_stat_scsi_tgt_dev_store_attr_##_name);
147
148#define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name) \
149static struct target_stat_scsi_tgt_dev_attribute \
150 target_stat_scsi_tgt_dev_##_name = \
151 __CONFIGFS_EATTR_RO(_name, \
152 target_stat_scsi_tgt_dev_show_attr_##_name);
153
154static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
155 struct se_dev_stat_grps *sgrps, char *page)
156{
157 struct se_device *dev =
158 container_of(sgrps, struct se_device, dev_stat_grps);
159 struct se_hba *hba = dev->se_hba;
160
161 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
162}
163DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
164
165static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
166 struct se_dev_stat_grps *sgrps, char *page)
167{
168 struct se_device *dev =
169 container_of(sgrps, struct se_device, dev_stat_grps);
170
171 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
172}
173DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
174
175static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
176 struct se_dev_stat_grps *sgrps, char *page)
177{
178 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
179}
180DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
181
182static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
183 struct se_dev_stat_grps *sgrps, char *page)
184{
185 struct se_device *dev =
186 container_of(sgrps, struct se_device, dev_stat_grps);
187
188 if (dev->export_count)
189 return snprintf(page, PAGE_SIZE, "activated");
190 else
191 return snprintf(page, PAGE_SIZE, "deactivated");
192}
193DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
194
195static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
196 struct se_dev_stat_grps *sgrps, char *page)
197{
198 struct se_device *dev =
199 container_of(sgrps, struct se_device, dev_stat_grps);
200 int non_accessible_lus;
201
202 if (dev->export_count)
203 non_accessible_lus = 0;
204 else
205 non_accessible_lus = 1;
206
207 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
208}
209DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
210
211static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
212 struct se_dev_stat_grps *sgrps, char *page)
213{
214 struct se_device *dev =
215 container_of(sgrps, struct se_device, dev_stat_grps);
216
217 return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
218}
219DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
220
221
222CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
223
224static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
225 &target_stat_scsi_tgt_dev_inst.attr,
226 &target_stat_scsi_tgt_dev_indx.attr,
227 &target_stat_scsi_tgt_dev_num_lus.attr,
228 &target_stat_scsi_tgt_dev_status.attr,
229 &target_stat_scsi_tgt_dev_non_access_lus.attr,
230 &target_stat_scsi_tgt_dev_resets.attr,
231 NULL,
232};
233
234static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
235 .show_attribute = target_stat_scsi_tgt_dev_attr_show,
236 .store_attribute = target_stat_scsi_tgt_dev_attr_store,
237};
238
239static struct config_item_type target_stat_scsi_tgt_dev_cit = {
240 .ct_item_ops = &target_stat_scsi_tgt_dev_attrib_ops,
241 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
242 .ct_owner = THIS_MODULE,
243};
244
245
246
247
248
249CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
250#define DEV_STAT_SCSI_LU_ATTR(_name, _mode) \
251static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
252 __CONFIGFS_EATTR(_name, _mode, \
253 target_stat_scsi_lu_show_attr_##_name, \
254 target_stat_scsi_lu_store_attr_##_name);
255
256#define DEV_STAT_SCSI_LU_ATTR_RO(_name) \
257static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
258 __CONFIGFS_EATTR_RO(_name, \
259 target_stat_scsi_lu_show_attr_##_name);
260
261static ssize_t target_stat_scsi_lu_show_attr_inst(
262 struct se_dev_stat_grps *sgrps, char *page)
263{
264 struct se_device *dev =
265 container_of(sgrps, struct se_device, dev_stat_grps);
266 struct se_hba *hba = dev->se_hba;
267
268 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
269}
270DEV_STAT_SCSI_LU_ATTR_RO(inst);
271
272static ssize_t target_stat_scsi_lu_show_attr_dev(
273 struct se_dev_stat_grps *sgrps, char *page)
274{
275 struct se_device *dev =
276 container_of(sgrps, struct se_device, dev_stat_grps);
277
278 return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
279}
280DEV_STAT_SCSI_LU_ATTR_RO(dev);
281
282static ssize_t target_stat_scsi_lu_show_attr_indx(
283 struct se_dev_stat_grps *sgrps, char *page)
284{
285 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
286}
287DEV_STAT_SCSI_LU_ATTR_RO(indx);
288
289static ssize_t target_stat_scsi_lu_show_attr_lun(
290 struct se_dev_stat_grps *sgrps, char *page)
291{
292
293 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
294}
295DEV_STAT_SCSI_LU_ATTR_RO(lun);
296
297static ssize_t target_stat_scsi_lu_show_attr_lu_name(
298 struct se_dev_stat_grps *sgrps, char *page)
299{
300 struct se_device *dev =
301 container_of(sgrps, struct se_device, dev_stat_grps);
302
303
304 return snprintf(page, PAGE_SIZE, "%s\n",
305 (strlen(dev->t10_wwn.unit_serial)) ?
306 dev->t10_wwn.unit_serial : "None");
307}
308DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
309
310static ssize_t target_stat_scsi_lu_show_attr_vend(
311 struct se_dev_stat_grps *sgrps, char *page)
312{
313 struct se_device *dev =
314 container_of(sgrps, struct se_device, dev_stat_grps);
315 int i;
316 char str[sizeof(dev->t10_wwn.vendor)+1];
317
318
319 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
320 str[i] = ISPRINT(dev->t10_wwn.vendor[i]) ?
321 dev->t10_wwn.vendor[i] : ' ';
322 str[i] = '\0';
323 return snprintf(page, PAGE_SIZE, "%s\n", str);
324}
325DEV_STAT_SCSI_LU_ATTR_RO(vend);
326
327static ssize_t target_stat_scsi_lu_show_attr_prod(
328 struct se_dev_stat_grps *sgrps, char *page)
329{
330 struct se_device *dev =
331 container_of(sgrps, struct se_device, dev_stat_grps);
332 int i;
333 char str[sizeof(dev->t10_wwn.model)+1];
334
335
336 for (i = 0; i < sizeof(dev->t10_wwn.vendor); i++)
337 str[i] = ISPRINT(dev->t10_wwn.model[i]) ?
338 dev->t10_wwn.model[i] : ' ';
339 str[i] = '\0';
340 return snprintf(page, PAGE_SIZE, "%s\n", str);
341}
342DEV_STAT_SCSI_LU_ATTR_RO(prod);
343
344static ssize_t target_stat_scsi_lu_show_attr_rev(
345 struct se_dev_stat_grps *sgrps, char *page)
346{
347 struct se_device *dev =
348 container_of(sgrps, struct se_device, dev_stat_grps);
349 int i;
350 char str[sizeof(dev->t10_wwn.revision)+1];
351
352
353 for (i = 0; i < sizeof(dev->t10_wwn.revision); i++)
354 str[i] = ISPRINT(dev->t10_wwn.revision[i]) ?
355 dev->t10_wwn.revision[i] : ' ';
356 str[i] = '\0';
357 return snprintf(page, PAGE_SIZE, "%s\n", str);
358}
359DEV_STAT_SCSI_LU_ATTR_RO(rev);
360
361static ssize_t target_stat_scsi_lu_show_attr_dev_type(
362 struct se_dev_stat_grps *sgrps, char *page)
363{
364 struct se_device *dev =
365 container_of(sgrps, struct se_device, dev_stat_grps);
366
367
368 return snprintf(page, PAGE_SIZE, "%u\n",
369 dev->transport->get_device_type(dev));
370}
371DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
372
373static ssize_t target_stat_scsi_lu_show_attr_status(
374 struct se_dev_stat_grps *sgrps, char *page)
375{
376 struct se_device *dev =
377 container_of(sgrps, struct se_device, dev_stat_grps);
378
379
380 return snprintf(page, PAGE_SIZE, "%s\n",
381 (dev->export_count) ? "available" : "notavailable");
382}
383DEV_STAT_SCSI_LU_ATTR_RO(status);
384
385static ssize_t target_stat_scsi_lu_show_attr_state_bit(
386 struct se_dev_stat_grps *sgrps, char *page)
387{
388
389 return snprintf(page, PAGE_SIZE, "exposed\n");
390}
391DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
392
393static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
394 struct se_dev_stat_grps *sgrps, char *page)
395{
396 struct se_device *dev =
397 container_of(sgrps, struct se_device, dev_stat_grps);
398
399
400 return snprintf(page, PAGE_SIZE, "%llu\n",
401 (unsigned long long)dev->num_cmds);
402}
403DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
404
405static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
406 struct se_dev_stat_grps *sgrps, char *page)
407{
408 struct se_device *dev =
409 container_of(sgrps, struct se_device, dev_stat_grps);
410
411
412 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->read_bytes >> 20));
413}
414DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
415
416static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
417 struct se_dev_stat_grps *sgrps, char *page)
418{
419 struct se_device *dev =
420 container_of(sgrps, struct se_device, dev_stat_grps);
421
422
423 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->write_bytes >> 20));
424}
425DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
426
427static ssize_t target_stat_scsi_lu_show_attr_resets(
428 struct se_dev_stat_grps *sgrps, char *page)
429{
430 struct se_device *dev =
431 container_of(sgrps, struct se_device, dev_stat_grps);
432
433
434 return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
435}
436DEV_STAT_SCSI_LU_ATTR_RO(resets);
437
438static ssize_t target_stat_scsi_lu_show_attr_full_stat(
439 struct se_dev_stat_grps *sgrps, char *page)
440{
441
442 return snprintf(page, PAGE_SIZE, "%u\n", 0);
443}
444DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
445
446static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
447 struct se_dev_stat_grps *sgrps, char *page)
448{
449
450 return snprintf(page, PAGE_SIZE, "%u\n", 0);
451}
452DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
453
454static ssize_t target_stat_scsi_lu_show_attr_creation_time(
455 struct se_dev_stat_grps *sgrps, char *page)
456{
457 struct se_device *dev =
458 container_of(sgrps, struct se_device, dev_stat_grps);
459
460
461 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
462 INITIAL_JIFFIES) * 100 / HZ));
463}
464DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
465
466CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
467
468static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
469 &target_stat_scsi_lu_inst.attr,
470 &target_stat_scsi_lu_dev.attr,
471 &target_stat_scsi_lu_indx.attr,
472 &target_stat_scsi_lu_lun.attr,
473 &target_stat_scsi_lu_lu_name.attr,
474 &target_stat_scsi_lu_vend.attr,
475 &target_stat_scsi_lu_prod.attr,
476 &target_stat_scsi_lu_rev.attr,
477 &target_stat_scsi_lu_dev_type.attr,
478 &target_stat_scsi_lu_status.attr,
479 &target_stat_scsi_lu_state_bit.attr,
480 &target_stat_scsi_lu_num_cmds.attr,
481 &target_stat_scsi_lu_read_mbytes.attr,
482 &target_stat_scsi_lu_write_mbytes.attr,
483 &target_stat_scsi_lu_resets.attr,
484 &target_stat_scsi_lu_full_stat.attr,
485 &target_stat_scsi_lu_hs_num_cmds.attr,
486 &target_stat_scsi_lu_creation_time.attr,
487 NULL,
488};
489
490static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
491 .show_attribute = target_stat_scsi_lu_attr_show,
492 .store_attribute = target_stat_scsi_lu_attr_store,
493};
494
495static struct config_item_type target_stat_scsi_lu_cit = {
496 .ct_item_ops = &target_stat_scsi_lu_attrib_ops,
497 .ct_attrs = target_stat_scsi_lu_attrs,
498 .ct_owner = THIS_MODULE,
499};
500
501
502
503
504
505void target_stat_setup_dev_default_groups(struct se_device *dev)
506{
507 struct config_group *dev_stat_grp = &dev->dev_stat_grps.stat_group;
508
509 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
510 "scsi_dev", &target_stat_scsi_dev_cit);
511 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
512 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
513 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
514 "scsi_lu", &target_stat_scsi_lu_cit);
515
516 dev_stat_grp->default_groups[0] = &dev->dev_stat_grps.scsi_dev_group;
517 dev_stat_grp->default_groups[1] = &dev->dev_stat_grps.scsi_tgt_dev_group;
518 dev_stat_grp->default_groups[2] = &dev->dev_stat_grps.scsi_lu_group;
519 dev_stat_grp->default_groups[3] = NULL;
520}
521
522
523
524
525
526CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
527#define DEV_STAT_SCSI_PORT_ATTR(_name, _mode) \
528static struct target_stat_scsi_port_attribute \
529 target_stat_scsi_port_##_name = \
530 __CONFIGFS_EATTR(_name, _mode, \
531 target_stat_scsi_port_show_attr_##_name, \
532 target_stat_scsi_port_store_attr_##_name);
533
534#define DEV_STAT_SCSI_PORT_ATTR_RO(_name) \
535static struct target_stat_scsi_port_attribute \
536 target_stat_scsi_port_##_name = \
537 __CONFIGFS_EATTR_RO(_name, \
538 target_stat_scsi_port_show_attr_##_name);
539
540static ssize_t target_stat_scsi_port_show_attr_inst(
541 struct se_port_stat_grps *pgrps, char *page)
542{
543 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
544 struct se_port *sep;
545 struct se_device *dev = lun->lun_se_dev;
546 struct se_hba *hba;
547 ssize_t ret;
548
549 spin_lock(&lun->lun_sep_lock);
550 sep = lun->lun_sep;
551 if (!sep) {
552 spin_unlock(&lun->lun_sep_lock);
553 return -ENODEV;
554 }
555 hba = dev->se_hba;
556 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
557 spin_unlock(&lun->lun_sep_lock);
558 return ret;
559}
560DEV_STAT_SCSI_PORT_ATTR_RO(inst);
561
562static ssize_t target_stat_scsi_port_show_attr_dev(
563 struct se_port_stat_grps *pgrps, char *page)
564{
565 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
566 struct se_port *sep;
567 struct se_device *dev = lun->lun_se_dev;
568 ssize_t ret;
569
570 spin_lock(&lun->lun_sep_lock);
571 sep = lun->lun_sep;
572 if (!sep) {
573 spin_unlock(&lun->lun_sep_lock);
574 return -ENODEV;
575 }
576 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
577 spin_unlock(&lun->lun_sep_lock);
578 return ret;
579}
580DEV_STAT_SCSI_PORT_ATTR_RO(dev);
581
582static ssize_t target_stat_scsi_port_show_attr_indx(
583 struct se_port_stat_grps *pgrps, char *page)
584{
585 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
586 struct se_port *sep;
587 ssize_t ret;
588
589 spin_lock(&lun->lun_sep_lock);
590 sep = lun->lun_sep;
591 if (!sep) {
592 spin_unlock(&lun->lun_sep_lock);
593 return -ENODEV;
594 }
595 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
596 spin_unlock(&lun->lun_sep_lock);
597 return ret;
598}
599DEV_STAT_SCSI_PORT_ATTR_RO(indx);
600
601static ssize_t target_stat_scsi_port_show_attr_role(
602 struct se_port_stat_grps *pgrps, char *page)
603{
604 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
605 struct se_device *dev = lun->lun_se_dev;
606 struct se_port *sep;
607 ssize_t ret;
608
609 if (!dev)
610 return -ENODEV;
611
612 spin_lock(&lun->lun_sep_lock);
613 sep = lun->lun_sep;
614 if (!sep) {
615 spin_unlock(&lun->lun_sep_lock);
616 return -ENODEV;
617 }
618 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
619 spin_unlock(&lun->lun_sep_lock);
620 return ret;
621}
622DEV_STAT_SCSI_PORT_ATTR_RO(role);
623
624static ssize_t target_stat_scsi_port_show_attr_busy_count(
625 struct se_port_stat_grps *pgrps, char *page)
626{
627 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
628 struct se_port *sep;
629 ssize_t ret;
630
631 spin_lock(&lun->lun_sep_lock);
632 sep = lun->lun_sep;
633 if (!sep) {
634 spin_unlock(&lun->lun_sep_lock);
635 return -ENODEV;
636 }
637
638 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
639 spin_unlock(&lun->lun_sep_lock);
640 return ret;
641}
642DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
643
644CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
645
646static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
647 &target_stat_scsi_port_inst.attr,
648 &target_stat_scsi_port_dev.attr,
649 &target_stat_scsi_port_indx.attr,
650 &target_stat_scsi_port_role.attr,
651 &target_stat_scsi_port_busy_count.attr,
652 NULL,
653};
654
655static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
656 .show_attribute = target_stat_scsi_port_attr_show,
657 .store_attribute = target_stat_scsi_port_attr_store,
658};
659
660static struct config_item_type target_stat_scsi_port_cit = {
661 .ct_item_ops = &target_stat_scsi_port_attrib_ops,
662 .ct_attrs = target_stat_scsi_port_attrs,
663 .ct_owner = THIS_MODULE,
664};
665
666
667
668
669CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
670#define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode) \
671static struct target_stat_scsi_tgt_port_attribute \
672 target_stat_scsi_tgt_port_##_name = \
673 __CONFIGFS_EATTR(_name, _mode, \
674 target_stat_scsi_tgt_port_show_attr_##_name, \
675 target_stat_scsi_tgt_port_store_attr_##_name);
676
677#define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name) \
678static struct target_stat_scsi_tgt_port_attribute \
679 target_stat_scsi_tgt_port_##_name = \
680 __CONFIGFS_EATTR_RO(_name, \
681 target_stat_scsi_tgt_port_show_attr_##_name);
682
683static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
684 struct se_port_stat_grps *pgrps, char *page)
685{
686 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
687 struct se_device *dev = lun->lun_se_dev;
688 struct se_port *sep;
689 struct se_hba *hba;
690 ssize_t ret;
691
692 spin_lock(&lun->lun_sep_lock);
693 sep = lun->lun_sep;
694 if (!sep) {
695 spin_unlock(&lun->lun_sep_lock);
696 return -ENODEV;
697 }
698 hba = dev->se_hba;
699 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
700 spin_unlock(&lun->lun_sep_lock);
701 return ret;
702}
703DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
704
705static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
706 struct se_port_stat_grps *pgrps, char *page)
707{
708 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
709 struct se_device *dev = lun->lun_se_dev;
710 struct se_port *sep;
711 ssize_t ret;
712
713 spin_lock(&lun->lun_sep_lock);
714 sep = lun->lun_sep;
715 if (!sep) {
716 spin_unlock(&lun->lun_sep_lock);
717 return -ENODEV;
718 }
719 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
720 spin_unlock(&lun->lun_sep_lock);
721 return ret;
722}
723DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
724
725static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
726 struct se_port_stat_grps *pgrps, char *page)
727{
728 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
729 struct se_port *sep;
730 ssize_t ret;
731
732 spin_lock(&lun->lun_sep_lock);
733 sep = lun->lun_sep;
734 if (!sep) {
735 spin_unlock(&lun->lun_sep_lock);
736 return -ENODEV;
737 }
738 ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
739 spin_unlock(&lun->lun_sep_lock);
740 return ret;
741}
742DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
743
744static ssize_t target_stat_scsi_tgt_port_show_attr_name(
745 struct se_port_stat_grps *pgrps, char *page)
746{
747 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
748 struct se_port *sep;
749 struct se_portal_group *tpg;
750 ssize_t ret;
751
752 spin_lock(&lun->lun_sep_lock);
753 sep = lun->lun_sep;
754 if (!sep) {
755 spin_unlock(&lun->lun_sep_lock);
756 return -ENODEV;
757 }
758 tpg = sep->sep_tpg;
759
760 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
761 tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
762 spin_unlock(&lun->lun_sep_lock);
763 return ret;
764}
765DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
766
767static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
768 struct se_port_stat_grps *pgrps, char *page)
769{
770 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
771 struct se_port *sep;
772 struct se_portal_group *tpg;
773 ssize_t ret;
774
775 spin_lock(&lun->lun_sep_lock);
776 sep = lun->lun_sep;
777 if (!sep) {
778 spin_unlock(&lun->lun_sep_lock);
779 return -ENODEV;
780 }
781 tpg = sep->sep_tpg;
782
783 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
784 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
785 tpg->se_tpg_tfo->tpg_get_tag(tpg));
786 spin_unlock(&lun->lun_sep_lock);
787 return ret;
788}
789DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
790
791static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
792 struct se_port_stat_grps *pgrps, char *page)
793{
794 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
795 struct se_port *sep;
796 ssize_t ret;
797
798 spin_lock(&lun->lun_sep_lock);
799 sep = lun->lun_sep;
800 if (!sep) {
801 spin_unlock(&lun->lun_sep_lock);
802 return -ENODEV;
803 }
804
805 ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
806 spin_unlock(&lun->lun_sep_lock);
807 return ret;
808}
809DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
810
811static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
812 struct se_port_stat_grps *pgrps, char *page)
813{
814 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
815 struct se_port *sep;
816 ssize_t ret;
817
818 spin_lock(&lun->lun_sep_lock);
819 sep = lun->lun_sep;
820 if (!sep) {
821 spin_unlock(&lun->lun_sep_lock);
822 return -ENODEV;
823 }
824
825 ret = snprintf(page, PAGE_SIZE, "%u\n",
826 (u32)(sep->sep_stats.rx_data_octets >> 20));
827 spin_unlock(&lun->lun_sep_lock);
828 return ret;
829}
830DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
831
832static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
833 struct se_port_stat_grps *pgrps, char *page)
834{
835 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
836 struct se_port *sep;
837 ssize_t ret;
838
839 spin_lock(&lun->lun_sep_lock);
840 sep = lun->lun_sep;
841 if (!sep) {
842 spin_unlock(&lun->lun_sep_lock);
843 return -ENODEV;
844 }
845
846 ret = snprintf(page, PAGE_SIZE, "%u\n",
847 (u32)(sep->sep_stats.tx_data_octets >> 20));
848 spin_unlock(&lun->lun_sep_lock);
849 return ret;
850}
851DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
852
853static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
854 struct se_port_stat_grps *pgrps, char *page)
855{
856 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
857 struct se_port *sep;
858 ssize_t ret;
859
860 spin_lock(&lun->lun_sep_lock);
861 sep = lun->lun_sep;
862 if (!sep) {
863 spin_unlock(&lun->lun_sep_lock);
864 return -ENODEV;
865 }
866
867
868 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
869 spin_unlock(&lun->lun_sep_lock);
870 return ret;
871}
872DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
873
874CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
875 scsi_tgt_port_group);
876
877static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
878 &target_stat_scsi_tgt_port_inst.attr,
879 &target_stat_scsi_tgt_port_dev.attr,
880 &target_stat_scsi_tgt_port_indx.attr,
881 &target_stat_scsi_tgt_port_name.attr,
882 &target_stat_scsi_tgt_port_port_index.attr,
883 &target_stat_scsi_tgt_port_in_cmds.attr,
884 &target_stat_scsi_tgt_port_write_mbytes.attr,
885 &target_stat_scsi_tgt_port_read_mbytes.attr,
886 &target_stat_scsi_tgt_port_hs_in_cmds.attr,
887 NULL,
888};
889
890static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
891 .show_attribute = target_stat_scsi_tgt_port_attr_show,
892 .store_attribute = target_stat_scsi_tgt_port_attr_store,
893};
894
895static struct config_item_type target_stat_scsi_tgt_port_cit = {
896 .ct_item_ops = &target_stat_scsi_tgt_port_attrib_ops,
897 .ct_attrs = target_stat_scsi_tgt_port_attrs,
898 .ct_owner = THIS_MODULE,
899};
900
901
902
903
904
905CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
906#define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode) \
907static struct target_stat_scsi_transport_attribute \
908 target_stat_scsi_transport_##_name = \
909 __CONFIGFS_EATTR(_name, _mode, \
910 target_stat_scsi_transport_show_attr_##_name, \
911 target_stat_scsi_transport_store_attr_##_name);
912
913#define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name) \
914static struct target_stat_scsi_transport_attribute \
915 target_stat_scsi_transport_##_name = \
916 __CONFIGFS_EATTR_RO(_name, \
917 target_stat_scsi_transport_show_attr_##_name);
918
919static ssize_t target_stat_scsi_transport_show_attr_inst(
920 struct se_port_stat_grps *pgrps, char *page)
921{
922 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
923 struct se_device *dev = lun->lun_se_dev;
924 struct se_port *sep;
925 struct se_hba *hba;
926 ssize_t ret;
927
928 spin_lock(&lun->lun_sep_lock);
929 sep = lun->lun_sep;
930 if (!sep) {
931 spin_unlock(&lun->lun_sep_lock);
932 return -ENODEV;
933 }
934
935 hba = dev->se_hba;
936 ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
937 spin_unlock(&lun->lun_sep_lock);
938 return ret;
939}
940DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
941
942static ssize_t target_stat_scsi_transport_show_attr_device(
943 struct se_port_stat_grps *pgrps, char *page)
944{
945 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
946 struct se_port *sep;
947 struct se_portal_group *tpg;
948 ssize_t ret;
949
950 spin_lock(&lun->lun_sep_lock);
951 sep = lun->lun_sep;
952 if (!sep) {
953 spin_unlock(&lun->lun_sep_lock);
954 return -ENODEV;
955 }
956 tpg = sep->sep_tpg;
957
958 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
959 tpg->se_tpg_tfo->get_fabric_name());
960 spin_unlock(&lun->lun_sep_lock);
961 return ret;
962}
963DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
964
965static ssize_t target_stat_scsi_transport_show_attr_indx(
966 struct se_port_stat_grps *pgrps, char *page)
967{
968 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
969 struct se_port *sep;
970 struct se_portal_group *tpg;
971 ssize_t ret;
972
973 spin_lock(&lun->lun_sep_lock);
974 sep = lun->lun_sep;
975 if (!sep) {
976 spin_unlock(&lun->lun_sep_lock);
977 return -ENODEV;
978 }
979 tpg = sep->sep_tpg;
980 ret = snprintf(page, PAGE_SIZE, "%u\n",
981 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
982 spin_unlock(&lun->lun_sep_lock);
983 return ret;
984}
985DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
986
987static ssize_t target_stat_scsi_transport_show_attr_dev_name(
988 struct se_port_stat_grps *pgrps, char *page)
989{
990 struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
991 struct se_device *dev = lun->lun_se_dev;
992 struct se_port *sep;
993 struct se_portal_group *tpg;
994 struct t10_wwn *wwn;
995 ssize_t ret;
996
997 spin_lock(&lun->lun_sep_lock);
998 sep = lun->lun_sep;
999 if (!sep) {
1000 spin_unlock(&lun->lun_sep_lock);
1001 return -ENODEV;
1002 }
1003 tpg = sep->sep_tpg;
1004 wwn = &dev->t10_wwn;
1005
1006 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1007 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1008 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
1009 wwn->vendor);
1010 spin_unlock(&lun->lun_sep_lock);
1011 return ret;
1012}
1013DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1014
1015CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1016 scsi_transport_group);
1017
1018static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1019 &target_stat_scsi_transport_inst.attr,
1020 &target_stat_scsi_transport_device.attr,
1021 &target_stat_scsi_transport_indx.attr,
1022 &target_stat_scsi_transport_dev_name.attr,
1023 NULL,
1024};
1025
1026static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1027 .show_attribute = target_stat_scsi_transport_attr_show,
1028 .store_attribute = target_stat_scsi_transport_attr_store,
1029};
1030
1031static struct config_item_type target_stat_scsi_transport_cit = {
1032 .ct_item_ops = &target_stat_scsi_transport_attrib_ops,
1033 .ct_attrs = target_stat_scsi_transport_attrs,
1034 .ct_owner = THIS_MODULE,
1035};
1036
1037
1038
1039
1040
1041void target_stat_setup_port_default_groups(struct se_lun *lun)
1042{
1043 struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1044
1045 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1046 "scsi_port", &target_stat_scsi_port_cit);
1047 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1048 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1049 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1050 "scsi_transport", &target_stat_scsi_transport_cit);
1051
1052 port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1053 port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1054 port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1055 port_stat_grp->default_groups[3] = NULL;
1056}
1057
1058
1059
1060
1061
1062CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1063#define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode) \
1064static struct target_stat_scsi_auth_intr_attribute \
1065 target_stat_scsi_auth_intr_##_name = \
1066 __CONFIGFS_EATTR(_name, _mode, \
1067 target_stat_scsi_auth_intr_show_attr_##_name, \
1068 target_stat_scsi_auth_intr_store_attr_##_name);
1069
1070#define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name) \
1071static struct target_stat_scsi_auth_intr_attribute \
1072 target_stat_scsi_auth_intr_##_name = \
1073 __CONFIGFS_EATTR_RO(_name, \
1074 target_stat_scsi_auth_intr_show_attr_##_name);
1075
1076static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1077 struct se_ml_stat_grps *lgrps, char *page)
1078{
1079 struct se_lun_acl *lacl = container_of(lgrps,
1080 struct se_lun_acl, ml_stat_grps);
1081 struct se_node_acl *nacl = lacl->se_lun_nacl;
1082 struct se_dev_entry *deve;
1083 struct se_portal_group *tpg;
1084 ssize_t ret;
1085
1086 spin_lock_irq(&nacl->device_list_lock);
1087 deve = nacl->device_list[lacl->mapped_lun];
1088 if (!deve->se_lun || !deve->se_lun_acl) {
1089 spin_unlock_irq(&nacl->device_list_lock);
1090 return -ENODEV;
1091 }
1092 tpg = nacl->se_tpg;
1093
1094 ret = snprintf(page, PAGE_SIZE, "%u\n",
1095 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1096 spin_unlock_irq(&nacl->device_list_lock);
1097 return ret;
1098}
1099DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1100
1101static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1102 struct se_ml_stat_grps *lgrps, char *page)
1103{
1104 struct se_lun_acl *lacl = container_of(lgrps,
1105 struct se_lun_acl, ml_stat_grps);
1106 struct se_node_acl *nacl = lacl->se_lun_nacl;
1107 struct se_dev_entry *deve;
1108 struct se_lun *lun;
1109 ssize_t ret;
1110
1111 spin_lock_irq(&nacl->device_list_lock);
1112 deve = nacl->device_list[lacl->mapped_lun];
1113 if (!deve->se_lun || !deve->se_lun_acl) {
1114 spin_unlock_irq(&nacl->device_list_lock);
1115 return -ENODEV;
1116 }
1117 lun = deve->se_lun;
1118
1119 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1120 spin_unlock_irq(&nacl->device_list_lock);
1121 return ret;
1122}
1123DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1124
1125static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1126 struct se_ml_stat_grps *lgrps, char *page)
1127{
1128 struct se_lun_acl *lacl = container_of(lgrps,
1129 struct se_lun_acl, ml_stat_grps);
1130 struct se_node_acl *nacl = lacl->se_lun_nacl;
1131 struct se_dev_entry *deve;
1132 struct se_portal_group *tpg;
1133 ssize_t ret;
1134
1135 spin_lock_irq(&nacl->device_list_lock);
1136 deve = nacl->device_list[lacl->mapped_lun];
1137 if (!deve->se_lun || !deve->se_lun_acl) {
1138 spin_unlock_irq(&nacl->device_list_lock);
1139 return -ENODEV;
1140 }
1141 tpg = nacl->se_tpg;
1142
1143 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1144 spin_unlock_irq(&nacl->device_list_lock);
1145 return ret;
1146}
1147DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1148
1149static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1150 struct se_ml_stat_grps *lgrps, char *page)
1151{
1152 struct se_lun_acl *lacl = container_of(lgrps,
1153 struct se_lun_acl, ml_stat_grps);
1154 struct se_node_acl *nacl = lacl->se_lun_nacl;
1155 struct se_dev_entry *deve;
1156 ssize_t ret;
1157
1158 spin_lock_irq(&nacl->device_list_lock);
1159 deve = nacl->device_list[lacl->mapped_lun];
1160 if (!deve->se_lun || !deve->se_lun_acl) {
1161 spin_unlock_irq(&nacl->device_list_lock);
1162 return -ENODEV;
1163 }
1164
1165 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1166 spin_unlock_irq(&nacl->device_list_lock);
1167 return ret;
1168}
1169DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1170
1171static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1172 struct se_ml_stat_grps *lgrps, char *page)
1173{
1174 struct se_lun_acl *lacl = container_of(lgrps,
1175 struct se_lun_acl, ml_stat_grps);
1176 struct se_node_acl *nacl = lacl->se_lun_nacl;
1177 struct se_dev_entry *deve;
1178 ssize_t ret;
1179
1180 spin_lock_irq(&nacl->device_list_lock);
1181 deve = nacl->device_list[lacl->mapped_lun];
1182 if (!deve->se_lun || !deve->se_lun_acl) {
1183 spin_unlock_irq(&nacl->device_list_lock);
1184 return -ENODEV;
1185 }
1186
1187 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1188 spin_unlock_irq(&nacl->device_list_lock);
1189 return ret;
1190}
1191DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1192
1193static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1194 struct se_ml_stat_grps *lgrps, char *page)
1195{
1196 struct se_lun_acl *lacl = container_of(lgrps,
1197 struct se_lun_acl, ml_stat_grps);
1198 struct se_node_acl *nacl = lacl->se_lun_nacl;
1199 struct se_dev_entry *deve;
1200 ssize_t ret;
1201
1202 spin_lock_irq(&nacl->device_list_lock);
1203 deve = nacl->device_list[lacl->mapped_lun];
1204 if (!deve->se_lun || !deve->se_lun_acl) {
1205 spin_unlock_irq(&nacl->device_list_lock);
1206 return -ENODEV;
1207 }
1208
1209 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1210 spin_unlock_irq(&nacl->device_list_lock);
1211 return ret;
1212}
1213DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1214
1215static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1216 struct se_ml_stat_grps *lgrps, char *page)
1217{
1218 struct se_lun_acl *lacl = container_of(lgrps,
1219 struct se_lun_acl, ml_stat_grps);
1220 struct se_node_acl *nacl = lacl->se_lun_nacl;
1221 struct se_dev_entry *deve;
1222 ssize_t ret;
1223
1224 spin_lock_irq(&nacl->device_list_lock);
1225 deve = nacl->device_list[lacl->mapped_lun];
1226 if (!deve->se_lun || !deve->se_lun_acl) {
1227 spin_unlock_irq(&nacl->device_list_lock);
1228 return -ENODEV;
1229 }
1230
1231 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1232 spin_unlock_irq(&nacl->device_list_lock);
1233 return ret;
1234}
1235DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1236
1237static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1238 struct se_ml_stat_grps *lgrps, char *page)
1239{
1240 struct se_lun_acl *lacl = container_of(lgrps,
1241 struct se_lun_acl, ml_stat_grps);
1242 struct se_node_acl *nacl = lacl->se_lun_nacl;
1243 struct se_dev_entry *deve;
1244 ssize_t ret;
1245
1246 spin_lock_irq(&nacl->device_list_lock);
1247 deve = nacl->device_list[lacl->mapped_lun];
1248 if (!deve->se_lun || !deve->se_lun_acl) {
1249 spin_unlock_irq(&nacl->device_list_lock);
1250 return -ENODEV;
1251 }
1252
1253 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1254 spin_unlock_irq(&nacl->device_list_lock);
1255 return ret;
1256}
1257DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1258
1259static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1260 struct se_ml_stat_grps *lgrps, char *page)
1261{
1262 struct se_lun_acl *lacl = container_of(lgrps,
1263 struct se_lun_acl, ml_stat_grps);
1264 struct se_node_acl *nacl = lacl->se_lun_nacl;
1265 struct se_dev_entry *deve;
1266 ssize_t ret;
1267
1268 spin_lock_irq(&nacl->device_list_lock);
1269 deve = nacl->device_list[lacl->mapped_lun];
1270 if (!deve->se_lun || !deve->se_lun_acl) {
1271 spin_unlock_irq(&nacl->device_list_lock);
1272 return -ENODEV;
1273 }
1274
1275 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1276 spin_unlock_irq(&nacl->device_list_lock);
1277 return ret;
1278}
1279DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1280
1281static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1282 struct se_ml_stat_grps *lgrps, char *page)
1283{
1284 struct se_lun_acl *lacl = container_of(lgrps,
1285 struct se_lun_acl, ml_stat_grps);
1286 struct se_node_acl *nacl = lacl->se_lun_nacl;
1287 struct se_dev_entry *deve;
1288 ssize_t ret;
1289
1290 spin_lock_irq(&nacl->device_list_lock);
1291 deve = nacl->device_list[lacl->mapped_lun];
1292 if (!deve->se_lun || !deve->se_lun_acl) {
1293 spin_unlock_irq(&nacl->device_list_lock);
1294 return -ENODEV;
1295 }
1296
1297 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1298 spin_unlock_irq(&nacl->device_list_lock);
1299 return ret;
1300}
1301DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1302
1303static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1304 struct se_ml_stat_grps *lgrps, char *page)
1305{
1306 struct se_lun_acl *lacl = container_of(lgrps,
1307 struct se_lun_acl, ml_stat_grps);
1308 struct se_node_acl *nacl = lacl->se_lun_nacl;
1309 struct se_dev_entry *deve;
1310 ssize_t ret;
1311
1312 spin_lock_irq(&nacl->device_list_lock);
1313 deve = nacl->device_list[lacl->mapped_lun];
1314 if (!deve->se_lun || !deve->se_lun_acl) {
1315 spin_unlock_irq(&nacl->device_list_lock);
1316 return -ENODEV;
1317 }
1318
1319 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1320 spin_unlock_irq(&nacl->device_list_lock);
1321 return ret;
1322}
1323DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1324
1325static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1326 struct se_ml_stat_grps *lgrps, char *page)
1327{
1328 struct se_lun_acl *lacl = container_of(lgrps,
1329 struct se_lun_acl, ml_stat_grps);
1330 struct se_node_acl *nacl = lacl->se_lun_nacl;
1331 struct se_dev_entry *deve;
1332 ssize_t ret;
1333
1334 spin_lock_irq(&nacl->device_list_lock);
1335 deve = nacl->device_list[lacl->mapped_lun];
1336 if (!deve->se_lun || !deve->se_lun_acl) {
1337 spin_unlock_irq(&nacl->device_list_lock);
1338 return -ENODEV;
1339 }
1340
1341 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1342 spin_unlock_irq(&nacl->device_list_lock);
1343 return ret;
1344}
1345DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1346
1347static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1348 struct se_ml_stat_grps *lgrps, char *page)
1349{
1350 struct se_lun_acl *lacl = container_of(lgrps,
1351 struct se_lun_acl, ml_stat_grps);
1352 struct se_node_acl *nacl = lacl->se_lun_nacl;
1353 struct se_dev_entry *deve;
1354 ssize_t ret;
1355
1356 spin_lock_irq(&nacl->device_list_lock);
1357 deve = nacl->device_list[lacl->mapped_lun];
1358 if (!deve->se_lun || !deve->se_lun_acl) {
1359 spin_unlock_irq(&nacl->device_list_lock);
1360 return -ENODEV;
1361 }
1362
1363 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1364 INITIAL_JIFFIES) * 100 / HZ));
1365 spin_unlock_irq(&nacl->device_list_lock);
1366 return ret;
1367}
1368DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1369
1370static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1371 struct se_ml_stat_grps *lgrps, char *page)
1372{
1373 struct se_lun_acl *lacl = container_of(lgrps,
1374 struct se_lun_acl, ml_stat_grps);
1375 struct se_node_acl *nacl = lacl->se_lun_nacl;
1376 struct se_dev_entry *deve;
1377 ssize_t ret;
1378
1379 spin_lock_irq(&nacl->device_list_lock);
1380 deve = nacl->device_list[lacl->mapped_lun];
1381 if (!deve->se_lun || !deve->se_lun_acl) {
1382 spin_unlock_irq(&nacl->device_list_lock);
1383 return -ENODEV;
1384 }
1385
1386 ret = snprintf(page, PAGE_SIZE, "Ready\n");
1387 spin_unlock_irq(&nacl->device_list_lock);
1388 return ret;
1389}
1390DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1391
1392CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1393 scsi_auth_intr_group);
1394
1395static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1396 &target_stat_scsi_auth_intr_inst.attr,
1397 &target_stat_scsi_auth_intr_dev.attr,
1398 &target_stat_scsi_auth_intr_port.attr,
1399 &target_stat_scsi_auth_intr_indx.attr,
1400 &target_stat_scsi_auth_intr_dev_or_port.attr,
1401 &target_stat_scsi_auth_intr_intr_name.attr,
1402 &target_stat_scsi_auth_intr_map_indx.attr,
1403 &target_stat_scsi_auth_intr_att_count.attr,
1404 &target_stat_scsi_auth_intr_num_cmds.attr,
1405 &target_stat_scsi_auth_intr_read_mbytes.attr,
1406 &target_stat_scsi_auth_intr_write_mbytes.attr,
1407 &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1408 &target_stat_scsi_auth_intr_creation_time.attr,
1409 &target_stat_scsi_auth_intr_row_status.attr,
1410 NULL,
1411};
1412
1413static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1414 .show_attribute = target_stat_scsi_auth_intr_attr_show,
1415 .store_attribute = target_stat_scsi_auth_intr_attr_store,
1416};
1417
1418static struct config_item_type target_stat_scsi_auth_intr_cit = {
1419 .ct_item_ops = &target_stat_scsi_auth_intr_attrib_ops,
1420 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1421 .ct_owner = THIS_MODULE,
1422};
1423
1424
1425
1426
1427
1428CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1429#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode) \
1430static struct target_stat_scsi_att_intr_port_attribute \
1431 target_stat_scsi_att_intr_port_##_name = \
1432 __CONFIGFS_EATTR(_name, _mode, \
1433 target_stat_scsi_att_intr_port_show_attr_##_name, \
1434 target_stat_scsi_att_intr_port_store_attr_##_name);
1435
1436#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name) \
1437static struct target_stat_scsi_att_intr_port_attribute \
1438 target_stat_scsi_att_intr_port_##_name = \
1439 __CONFIGFS_EATTR_RO(_name, \
1440 target_stat_scsi_att_intr_port_show_attr_##_name);
1441
1442static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1443 struct se_ml_stat_grps *lgrps, char *page)
1444{
1445 struct se_lun_acl *lacl = container_of(lgrps,
1446 struct se_lun_acl, ml_stat_grps);
1447 struct se_node_acl *nacl = lacl->se_lun_nacl;
1448 struct se_dev_entry *deve;
1449 struct se_portal_group *tpg;
1450 ssize_t ret;
1451
1452 spin_lock_irq(&nacl->device_list_lock);
1453 deve = nacl->device_list[lacl->mapped_lun];
1454 if (!deve->se_lun || !deve->se_lun_acl) {
1455 spin_unlock_irq(&nacl->device_list_lock);
1456 return -ENODEV;
1457 }
1458 tpg = nacl->se_tpg;
1459
1460 ret = snprintf(page, PAGE_SIZE, "%u\n",
1461 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1462 spin_unlock_irq(&nacl->device_list_lock);
1463 return ret;
1464}
1465DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1466
1467static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1468 struct se_ml_stat_grps *lgrps, char *page)
1469{
1470 struct se_lun_acl *lacl = container_of(lgrps,
1471 struct se_lun_acl, ml_stat_grps);
1472 struct se_node_acl *nacl = lacl->se_lun_nacl;
1473 struct se_dev_entry *deve;
1474 struct se_lun *lun;
1475 ssize_t ret;
1476
1477 spin_lock_irq(&nacl->device_list_lock);
1478 deve = nacl->device_list[lacl->mapped_lun];
1479 if (!deve->se_lun || !deve->se_lun_acl) {
1480 spin_unlock_irq(&nacl->device_list_lock);
1481 return -ENODEV;
1482 }
1483 lun = deve->se_lun;
1484
1485 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1486 spin_unlock_irq(&nacl->device_list_lock);
1487 return ret;
1488}
1489DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1490
1491static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1492 struct se_ml_stat_grps *lgrps, char *page)
1493{
1494 struct se_lun_acl *lacl = container_of(lgrps,
1495 struct se_lun_acl, ml_stat_grps);
1496 struct se_node_acl *nacl = lacl->se_lun_nacl;
1497 struct se_dev_entry *deve;
1498 struct se_portal_group *tpg;
1499 ssize_t ret;
1500
1501 spin_lock_irq(&nacl->device_list_lock);
1502 deve = nacl->device_list[lacl->mapped_lun];
1503 if (!deve->se_lun || !deve->se_lun_acl) {
1504 spin_unlock_irq(&nacl->device_list_lock);
1505 return -ENODEV;
1506 }
1507 tpg = nacl->se_tpg;
1508
1509 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1510 spin_unlock_irq(&nacl->device_list_lock);
1511 return ret;
1512}
1513DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1514
1515static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1516 struct se_ml_stat_grps *lgrps, char *page)
1517{
1518 struct se_lun_acl *lacl = container_of(lgrps,
1519 struct se_lun_acl, ml_stat_grps);
1520 struct se_node_acl *nacl = lacl->se_lun_nacl;
1521 struct se_session *se_sess;
1522 struct se_portal_group *tpg;
1523 ssize_t ret;
1524
1525 spin_lock_irq(&nacl->nacl_sess_lock);
1526 se_sess = nacl->nacl_sess;
1527 if (!se_sess) {
1528 spin_unlock_irq(&nacl->nacl_sess_lock);
1529 return -ENODEV;
1530 }
1531
1532 tpg = nacl->se_tpg;
1533
1534 ret = snprintf(page, PAGE_SIZE, "%u\n",
1535 tpg->se_tpg_tfo->sess_get_index(se_sess));
1536 spin_unlock_irq(&nacl->nacl_sess_lock);
1537 return ret;
1538}
1539DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1540
1541static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1542 struct se_ml_stat_grps *lgrps, char *page)
1543{
1544 struct se_lun_acl *lacl = container_of(lgrps,
1545 struct se_lun_acl, ml_stat_grps);
1546 struct se_node_acl *nacl = lacl->se_lun_nacl;
1547 struct se_dev_entry *deve;
1548 ssize_t ret;
1549
1550 spin_lock_irq(&nacl->device_list_lock);
1551 deve = nacl->device_list[lacl->mapped_lun];
1552 if (!deve->se_lun || !deve->se_lun_acl) {
1553 spin_unlock_irq(&nacl->device_list_lock);
1554 return -ENODEV;
1555 }
1556
1557 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1558 spin_unlock_irq(&nacl->device_list_lock);
1559 return ret;
1560}
1561DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1562
1563static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1564 struct se_ml_stat_grps *lgrps, char *page)
1565{
1566 struct se_lun_acl *lacl = container_of(lgrps,
1567 struct se_lun_acl, ml_stat_grps);
1568 struct se_node_acl *nacl = lacl->se_lun_nacl;
1569 struct se_session *se_sess;
1570 struct se_portal_group *tpg;
1571 ssize_t ret;
1572 unsigned char buf[64];
1573
1574 spin_lock_irq(&nacl->nacl_sess_lock);
1575 se_sess = nacl->nacl_sess;
1576 if (!se_sess) {
1577 spin_unlock_irq(&nacl->nacl_sess_lock);
1578 return -ENODEV;
1579 }
1580
1581 tpg = nacl->se_tpg;
1582
1583 memset(buf, 0, 64);
1584 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1585 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1586
1587 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1588 spin_unlock_irq(&nacl->nacl_sess_lock);
1589 return ret;
1590}
1591DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1592
1593CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1594 scsi_att_intr_port_group);
1595
1596static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1597 &target_stat_scsi_att_intr_port_inst.attr,
1598 &target_stat_scsi_att_intr_port_dev.attr,
1599 &target_stat_scsi_att_intr_port_port.attr,
1600 &target_stat_scsi_att_intr_port_indx.attr,
1601 &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1602 &target_stat_scsi_att_intr_port_port_ident.attr,
1603 NULL,
1604};
1605
1606static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1607 .show_attribute = target_stat_scsi_att_intr_port_attr_show,
1608 .store_attribute = target_stat_scsi_att_intr_port_attr_store,
1609};
1610
1611static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1612 .ct_item_ops = &target_stat_scsi_att_intr_port_attrib_ops,
1613 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1614 .ct_owner = THIS_MODULE,
1615};
1616
1617
1618
1619
1620
1621void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1622{
1623 struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1624
1625 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1626 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1627 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1628 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1629
1630 ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1631 ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1632 ml_stat_grp->default_groups[2] = NULL;
1633}
1634
