1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/module.h>
16#include <linux/delay.h>
17#include <linux/timer.h>
18#include <linux/string.h>
19#include <linux/utsname.h>
20#include <linux/proc_fs.h>
21#include <linux/seq_file.h>
22#include <linux/configfs.h>
23
24#include <target/target_core_base.h>
25#include <target/target_core_backend.h>
26#include <target/target_core_fabric.h>
27
28#include "target_core_internal.h"
29
30#ifndef INITIAL_JIFFIES
31#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
32#endif
33
34#define SCSI_LU_INDEX 1
35#define LU_COUNT 1
36
37
38
39
40
41static struct se_device *to_stat_dev(struct config_item *item)
42{
43 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
44 struct se_dev_stat_grps, scsi_dev_group);
45 return container_of(sgrps, struct se_device, dev_stat_grps);
46}
47
48static ssize_t target_stat_inst_show(struct config_item *item, char *page)
49{
50 struct se_hba *hba = to_stat_dev(item)->se_hba;
51
52 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
53}
54
55static ssize_t target_stat_indx_show(struct config_item *item, char *page)
56{
57 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->dev_index);
58}
59
60static ssize_t target_stat_role_show(struct config_item *item, char *page)
61{
62 return snprintf(page, PAGE_SIZE, "Target\n");
63}
64
65static ssize_t target_stat_ports_show(struct config_item *item, char *page)
66{
67 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_dev(item)->export_count);
68}
69
70CONFIGFS_ATTR_RO(target_stat_, inst);
71CONFIGFS_ATTR_RO(target_stat_, indx);
72CONFIGFS_ATTR_RO(target_stat_, role);
73CONFIGFS_ATTR_RO(target_stat_, ports);
74
75static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
76 &target_stat_attr_inst,
77 &target_stat_attr_indx,
78 &target_stat_attr_role,
79 &target_stat_attr_ports,
80 NULL,
81};
82
83static const struct config_item_type target_stat_scsi_dev_cit = {
84 .ct_attrs = target_stat_scsi_dev_attrs,
85 .ct_owner = THIS_MODULE,
86};
87
88
89
90
91static struct se_device *to_stat_tgt_dev(struct config_item *item)
92{
93 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
94 struct se_dev_stat_grps, scsi_tgt_dev_group);
95 return container_of(sgrps, struct se_device, dev_stat_grps);
96}
97
98static ssize_t target_stat_tgt_inst_show(struct config_item *item, char *page)
99{
100 struct se_hba *hba = to_stat_tgt_dev(item)->se_hba;
101
102 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
103}
104
105static ssize_t target_stat_tgt_indx_show(struct config_item *item, char *page)
106{
107 return snprintf(page, PAGE_SIZE, "%u\n", to_stat_tgt_dev(item)->dev_index);
108}
109
110static ssize_t target_stat_tgt_num_lus_show(struct config_item *item,
111 char *page)
112{
113 return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
114}
115
116static ssize_t target_stat_tgt_status_show(struct config_item *item,
117 char *page)
118{
119 if (to_stat_tgt_dev(item)->export_count)
120 return snprintf(page, PAGE_SIZE, "activated");
121 else
122 return snprintf(page, PAGE_SIZE, "deactivated");
123}
124
125static ssize_t target_stat_tgt_non_access_lus_show(struct config_item *item,
126 char *page)
127{
128 int non_accessible_lus;
129
130 if (to_stat_tgt_dev(item)->export_count)
131 non_accessible_lus = 0;
132 else
133 non_accessible_lus = 1;
134
135 return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
136}
137
138static ssize_t target_stat_tgt_resets_show(struct config_item *item,
139 char *page)
140{
141 return snprintf(page, PAGE_SIZE, "%lu\n",
142 atomic_long_read(&to_stat_tgt_dev(item)->num_resets));
143}
144
145static ssize_t target_stat_tgt_aborts_complete_show(struct config_item *item,
146 char *page)
147{
148 return snprintf(page, PAGE_SIZE, "%lu\n",
149 atomic_long_read(&to_stat_tgt_dev(item)->aborts_complete));
150}
151
152static ssize_t target_stat_tgt_aborts_no_task_show(struct config_item *item,
153 char *page)
154{
155 return snprintf(page, PAGE_SIZE, "%lu\n",
156 atomic_long_read(&to_stat_tgt_dev(item)->aborts_no_task));
157}
158
159CONFIGFS_ATTR_RO(target_stat_tgt_, inst);
160CONFIGFS_ATTR_RO(target_stat_tgt_, indx);
161CONFIGFS_ATTR_RO(target_stat_tgt_, num_lus);
162CONFIGFS_ATTR_RO(target_stat_tgt_, status);
163CONFIGFS_ATTR_RO(target_stat_tgt_, non_access_lus);
164CONFIGFS_ATTR_RO(target_stat_tgt_, resets);
165CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_complete);
166CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_no_task);
167
168static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
169 &target_stat_tgt_attr_inst,
170 &target_stat_tgt_attr_indx,
171 &target_stat_tgt_attr_num_lus,
172 &target_stat_tgt_attr_status,
173 &target_stat_tgt_attr_non_access_lus,
174 &target_stat_tgt_attr_resets,
175 &target_stat_tgt_attr_aborts_complete,
176 &target_stat_tgt_attr_aborts_no_task,
177 NULL,
178};
179
180static const struct config_item_type target_stat_scsi_tgt_dev_cit = {
181 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
182 .ct_owner = THIS_MODULE,
183};
184
185
186
187
188
189static struct se_device *to_stat_lu_dev(struct config_item *item)
190{
191 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
192 struct se_dev_stat_grps, scsi_lu_group);
193 return container_of(sgrps, struct se_device, dev_stat_grps);
194}
195
196static ssize_t target_stat_lu_inst_show(struct config_item *item, char *page)
197{
198 struct se_hba *hba = to_stat_lu_dev(item)->se_hba;
199
200 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
201}
202
203static ssize_t target_stat_lu_dev_show(struct config_item *item, char *page)
204{
205 return snprintf(page, PAGE_SIZE, "%u\n",
206 to_stat_lu_dev(item)->dev_index);
207}
208
209static ssize_t target_stat_lu_indx_show(struct config_item *item, char *page)
210{
211 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
212}
213
214static ssize_t target_stat_lu_lun_show(struct config_item *item, char *page)
215{
216
217 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
218}
219
220static ssize_t target_stat_lu_lu_name_show(struct config_item *item, char *page)
221{
222 struct se_device *dev = to_stat_lu_dev(item);
223
224
225 return snprintf(page, PAGE_SIZE, "%s\n",
226 (strlen(dev->t10_wwn.unit_serial)) ?
227 dev->t10_wwn.unit_serial : "None");
228}
229
230static ssize_t target_stat_lu_vend_show(struct config_item *item, char *page)
231{
232 struct se_device *dev = to_stat_lu_dev(item);
233
234 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_VENDOR_LEN)
235 "s\n", dev->t10_wwn.vendor);
236}
237
238static ssize_t target_stat_lu_prod_show(struct config_item *item, char *page)
239{
240 struct se_device *dev = to_stat_lu_dev(item);
241
242 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_MODEL_LEN)
243 "s\n", dev->t10_wwn.model);
244}
245
246static ssize_t target_stat_lu_rev_show(struct config_item *item, char *page)
247{
248 struct se_device *dev = to_stat_lu_dev(item);
249
250 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_REVISION_LEN)
251 "s\n", dev->t10_wwn.revision);
252}
253
254static ssize_t target_stat_lu_dev_type_show(struct config_item *item, char *page)
255{
256 struct se_device *dev = to_stat_lu_dev(item);
257
258
259 return snprintf(page, PAGE_SIZE, "%u\n",
260 dev->transport->get_device_type(dev));
261}
262
263static ssize_t target_stat_lu_status_show(struct config_item *item, char *page)
264{
265 struct se_device *dev = to_stat_lu_dev(item);
266
267
268 return snprintf(page, PAGE_SIZE, "%s\n",
269 (dev->export_count) ? "available" : "notavailable");
270}
271
272static ssize_t target_stat_lu_state_bit_show(struct config_item *item,
273 char *page)
274{
275
276 return snprintf(page, PAGE_SIZE, "exposed\n");
277}
278
279static ssize_t target_stat_lu_num_cmds_show(struct config_item *item,
280 char *page)
281{
282 struct se_device *dev = to_stat_lu_dev(item);
283
284
285 return snprintf(page, PAGE_SIZE, "%lu\n",
286 atomic_long_read(&dev->num_cmds));
287}
288
289static ssize_t target_stat_lu_read_mbytes_show(struct config_item *item,
290 char *page)
291{
292 struct se_device *dev = to_stat_lu_dev(item);
293
294
295 return snprintf(page, PAGE_SIZE, "%lu\n",
296 atomic_long_read(&dev->read_bytes) >> 20);
297}
298
299static ssize_t target_stat_lu_write_mbytes_show(struct config_item *item,
300 char *page)
301{
302 struct se_device *dev = to_stat_lu_dev(item);
303
304
305 return snprintf(page, PAGE_SIZE, "%lu\n",
306 atomic_long_read(&dev->write_bytes) >> 20);
307}
308
309static ssize_t target_stat_lu_resets_show(struct config_item *item, char *page)
310{
311 struct se_device *dev = to_stat_lu_dev(item);
312
313
314 return snprintf(page, PAGE_SIZE, "%lu\n",
315 atomic_long_read(&dev->num_resets));
316}
317
318static ssize_t target_stat_lu_full_stat_show(struct config_item *item,
319 char *page)
320{
321
322 return snprintf(page, PAGE_SIZE, "%u\n", 0);
323}
324
325static ssize_t target_stat_lu_hs_num_cmds_show(struct config_item *item,
326 char *page)
327{
328
329 return snprintf(page, PAGE_SIZE, "%u\n", 0);
330}
331
332static ssize_t target_stat_lu_creation_time_show(struct config_item *item,
333 char *page)
334{
335 struct se_device *dev = to_stat_lu_dev(item);
336
337
338 return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
339 INITIAL_JIFFIES) * 100 / HZ));
340}
341
342CONFIGFS_ATTR_RO(target_stat_lu_, inst);
343CONFIGFS_ATTR_RO(target_stat_lu_, dev);
344CONFIGFS_ATTR_RO(target_stat_lu_, indx);
345CONFIGFS_ATTR_RO(target_stat_lu_, lun);
346CONFIGFS_ATTR_RO(target_stat_lu_, lu_name);
347CONFIGFS_ATTR_RO(target_stat_lu_, vend);
348CONFIGFS_ATTR_RO(target_stat_lu_, prod);
349CONFIGFS_ATTR_RO(target_stat_lu_, rev);
350CONFIGFS_ATTR_RO(target_stat_lu_, dev_type);
351CONFIGFS_ATTR_RO(target_stat_lu_, status);
352CONFIGFS_ATTR_RO(target_stat_lu_, state_bit);
353CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds);
354CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes);
355CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes);
356CONFIGFS_ATTR_RO(target_stat_lu_, resets);
357CONFIGFS_ATTR_RO(target_stat_lu_, full_stat);
358CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds);
359CONFIGFS_ATTR_RO(target_stat_lu_, creation_time);
360
361static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
362 &target_stat_lu_attr_inst,
363 &target_stat_lu_attr_dev,
364 &target_stat_lu_attr_indx,
365 &target_stat_lu_attr_lun,
366 &target_stat_lu_attr_lu_name,
367 &target_stat_lu_attr_vend,
368 &target_stat_lu_attr_prod,
369 &target_stat_lu_attr_rev,
370 &target_stat_lu_attr_dev_type,
371 &target_stat_lu_attr_status,
372 &target_stat_lu_attr_state_bit,
373 &target_stat_lu_attr_num_cmds,
374 &target_stat_lu_attr_read_mbytes,
375 &target_stat_lu_attr_write_mbytes,
376 &target_stat_lu_attr_resets,
377 &target_stat_lu_attr_full_stat,
378 &target_stat_lu_attr_hs_num_cmds,
379 &target_stat_lu_attr_creation_time,
380 NULL,
381};
382
383static const struct config_item_type target_stat_scsi_lu_cit = {
384 .ct_attrs = target_stat_scsi_lu_attrs,
385 .ct_owner = THIS_MODULE,
386};
387
388
389
390
391
392void target_stat_setup_dev_default_groups(struct se_device *dev)
393{
394 config_group_init_type_name(&dev->dev_stat_grps.scsi_dev_group,
395 "scsi_dev", &target_stat_scsi_dev_cit);
396 configfs_add_default_group(&dev->dev_stat_grps.scsi_dev_group,
397 &dev->dev_stat_grps.stat_group);
398
399 config_group_init_type_name(&dev->dev_stat_grps.scsi_tgt_dev_group,
400 "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
401 configfs_add_default_group(&dev->dev_stat_grps.scsi_tgt_dev_group,
402 &dev->dev_stat_grps.stat_group);
403
404 config_group_init_type_name(&dev->dev_stat_grps.scsi_lu_group,
405 "scsi_lu", &target_stat_scsi_lu_cit);
406 configfs_add_default_group(&dev->dev_stat_grps.scsi_lu_group,
407 &dev->dev_stat_grps.stat_group);
408}
409
410
411
412
413
414static struct se_lun *to_stat_port(struct config_item *item)
415{
416 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
417 struct se_port_stat_grps, scsi_port_group);
418 return container_of(pgrps, struct se_lun, port_stat_grps);
419}
420
421static ssize_t target_stat_port_inst_show(struct config_item *item, char *page)
422{
423 struct se_lun *lun = to_stat_port(item);
424 struct se_device *dev;
425 ssize_t ret = -ENODEV;
426
427 rcu_read_lock();
428 dev = rcu_dereference(lun->lun_se_dev);
429 if (dev)
430 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
431 rcu_read_unlock();
432 return ret;
433}
434
435static ssize_t target_stat_port_dev_show(struct config_item *item, char *page)
436{
437 struct se_lun *lun = to_stat_port(item);
438 struct se_device *dev;
439 ssize_t ret = -ENODEV;
440
441 rcu_read_lock();
442 dev = rcu_dereference(lun->lun_se_dev);
443 if (dev)
444 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
445 rcu_read_unlock();
446 return ret;
447}
448
449static ssize_t target_stat_port_indx_show(struct config_item *item, char *page)
450{
451 struct se_lun *lun = to_stat_port(item);
452 struct se_device *dev;
453 ssize_t ret = -ENODEV;
454
455 rcu_read_lock();
456 dev = rcu_dereference(lun->lun_se_dev);
457 if (dev)
458 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
459 rcu_read_unlock();
460 return ret;
461}
462
463static ssize_t target_stat_port_role_show(struct config_item *item, char *page)
464{
465 struct se_lun *lun = to_stat_port(item);
466 struct se_device *dev;
467 ssize_t ret = -ENODEV;
468
469 rcu_read_lock();
470 dev = rcu_dereference(lun->lun_se_dev);
471 if (dev)
472 ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
473 rcu_read_unlock();
474 return ret;
475}
476
477static ssize_t target_stat_port_busy_count_show(struct config_item *item,
478 char *page)
479{
480 struct se_lun *lun = to_stat_port(item);
481 struct se_device *dev;
482 ssize_t ret = -ENODEV;
483
484 rcu_read_lock();
485 dev = rcu_dereference(lun->lun_se_dev);
486 if (dev) {
487
488 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
489 }
490 rcu_read_unlock();
491 return ret;
492}
493
494CONFIGFS_ATTR_RO(target_stat_port_, inst);
495CONFIGFS_ATTR_RO(target_stat_port_, dev);
496CONFIGFS_ATTR_RO(target_stat_port_, indx);
497CONFIGFS_ATTR_RO(target_stat_port_, role);
498CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
499
500static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
501 &target_stat_port_attr_inst,
502 &target_stat_port_attr_dev,
503 &target_stat_port_attr_indx,
504 &target_stat_port_attr_role,
505 &target_stat_port_attr_busy_count,
506 NULL,
507};
508
509static const struct config_item_type target_stat_scsi_port_cit = {
510 .ct_attrs = target_stat_scsi_port_attrs,
511 .ct_owner = THIS_MODULE,
512};
513
514
515
516
517static struct se_lun *to_stat_tgt_port(struct config_item *item)
518{
519 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
520 struct se_port_stat_grps, scsi_tgt_port_group);
521 return container_of(pgrps, struct se_lun, port_stat_grps);
522}
523
524static ssize_t target_stat_tgt_port_inst_show(struct config_item *item,
525 char *page)
526{
527 struct se_lun *lun = to_stat_tgt_port(item);
528 struct se_device *dev;
529 ssize_t ret = -ENODEV;
530
531 rcu_read_lock();
532 dev = rcu_dereference(lun->lun_se_dev);
533 if (dev)
534 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
535 rcu_read_unlock();
536 return ret;
537}
538
539static ssize_t target_stat_tgt_port_dev_show(struct config_item *item,
540 char *page)
541{
542 struct se_lun *lun = to_stat_tgt_port(item);
543 struct se_device *dev;
544 ssize_t ret = -ENODEV;
545
546 rcu_read_lock();
547 dev = rcu_dereference(lun->lun_se_dev);
548 if (dev)
549 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
550 rcu_read_unlock();
551 return ret;
552}
553
554static ssize_t target_stat_tgt_port_indx_show(struct config_item *item,
555 char *page)
556{
557 struct se_lun *lun = to_stat_tgt_port(item);
558 struct se_device *dev;
559 ssize_t ret = -ENODEV;
560
561 rcu_read_lock();
562 dev = rcu_dereference(lun->lun_se_dev);
563 if (dev)
564 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_rtpi);
565 rcu_read_unlock();
566 return ret;
567}
568
569static ssize_t target_stat_tgt_port_name_show(struct config_item *item,
570 char *page)
571{
572 struct se_lun *lun = to_stat_tgt_port(item);
573 struct se_portal_group *tpg = lun->lun_tpg;
574 struct se_device *dev;
575 ssize_t ret = -ENODEV;
576
577 rcu_read_lock();
578 dev = rcu_dereference(lun->lun_se_dev);
579 if (dev)
580 ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
581 tpg->se_tpg_tfo->fabric_name,
582 lun->lun_rtpi);
583 rcu_read_unlock();
584 return ret;
585}
586
587static ssize_t target_stat_tgt_port_port_index_show(struct config_item *item,
588 char *page)
589{
590 struct se_lun *lun = to_stat_tgt_port(item);
591 struct se_portal_group *tpg = lun->lun_tpg;
592 struct se_device *dev;
593 ssize_t ret = -ENODEV;
594
595 rcu_read_lock();
596 dev = rcu_dereference(lun->lun_se_dev);
597 if (dev)
598 ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
599 tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
600 tpg->se_tpg_tfo->tpg_get_tag(tpg));
601 rcu_read_unlock();
602 return ret;
603}
604
605static ssize_t target_stat_tgt_port_in_cmds_show(struct config_item *item,
606 char *page)
607{
608 struct se_lun *lun = to_stat_tgt_port(item);
609 struct se_device *dev;
610 ssize_t ret = -ENODEV;
611
612 rcu_read_lock();
613 dev = rcu_dereference(lun->lun_se_dev);
614 if (dev)
615 ret = snprintf(page, PAGE_SIZE, "%lu\n",
616 atomic_long_read(&lun->lun_stats.cmd_pdus));
617 rcu_read_unlock();
618 return ret;
619}
620
621static ssize_t target_stat_tgt_port_write_mbytes_show(struct config_item *item,
622 char *page)
623{
624 struct se_lun *lun = to_stat_tgt_port(item);
625 struct se_device *dev;
626 ssize_t ret = -ENODEV;
627
628 rcu_read_lock();
629 dev = rcu_dereference(lun->lun_se_dev);
630 if (dev)
631 ret = snprintf(page, PAGE_SIZE, "%u\n",
632 (u32)(atomic_long_read(&lun->lun_stats.rx_data_octets) >> 20));
633 rcu_read_unlock();
634 return ret;
635}
636
637static ssize_t target_stat_tgt_port_read_mbytes_show(struct config_item *item,
638 char *page)
639{
640 struct se_lun *lun = to_stat_tgt_port(item);
641 struct se_device *dev;
642 ssize_t ret = -ENODEV;
643
644 rcu_read_lock();
645 dev = rcu_dereference(lun->lun_se_dev);
646 if (dev)
647 ret = snprintf(page, PAGE_SIZE, "%u\n",
648 (u32)(atomic_long_read(&lun->lun_stats.tx_data_octets) >> 20));
649 rcu_read_unlock();
650 return ret;
651}
652
653static ssize_t target_stat_tgt_port_hs_in_cmds_show(struct config_item *item,
654 char *page)
655{
656 struct se_lun *lun = to_stat_tgt_port(item);
657 struct se_device *dev;
658 ssize_t ret = -ENODEV;
659
660 rcu_read_lock();
661 dev = rcu_dereference(lun->lun_se_dev);
662 if (dev) {
663
664 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
665 }
666 rcu_read_unlock();
667 return ret;
668}
669
670CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
671CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
672CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
673CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
674CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
675CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
676CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
677CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
678CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
679
680static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
681 &target_stat_tgt_port_attr_inst,
682 &target_stat_tgt_port_attr_dev,
683 &target_stat_tgt_port_attr_indx,
684 &target_stat_tgt_port_attr_name,
685 &target_stat_tgt_port_attr_port_index,
686 &target_stat_tgt_port_attr_in_cmds,
687 &target_stat_tgt_port_attr_write_mbytes,
688 &target_stat_tgt_port_attr_read_mbytes,
689 &target_stat_tgt_port_attr_hs_in_cmds,
690 NULL,
691};
692
693static const struct config_item_type target_stat_scsi_tgt_port_cit = {
694 .ct_attrs = target_stat_scsi_tgt_port_attrs,
695 .ct_owner = THIS_MODULE,
696};
697
698
699
700
701static struct se_lun *to_transport_stat(struct config_item *item)
702{
703 struct se_port_stat_grps *pgrps = container_of(to_config_group(item),
704 struct se_port_stat_grps, scsi_transport_group);
705 return container_of(pgrps, struct se_lun, port_stat_grps);
706}
707
708static ssize_t target_stat_transport_inst_show(struct config_item *item,
709 char *page)
710{
711 struct se_lun *lun = to_transport_stat(item);
712 struct se_device *dev;
713 ssize_t ret = -ENODEV;
714
715 rcu_read_lock();
716 dev = rcu_dereference(lun->lun_se_dev);
717 if (dev)
718 ret = snprintf(page, PAGE_SIZE, "%u\n", dev->hba_index);
719 rcu_read_unlock();
720 return ret;
721}
722
723static ssize_t target_stat_transport_device_show(struct config_item *item,
724 char *page)
725{
726 struct se_lun *lun = to_transport_stat(item);
727 struct se_device *dev;
728 struct se_portal_group *tpg = lun->lun_tpg;
729 ssize_t ret = -ENODEV;
730
731 rcu_read_lock();
732 dev = rcu_dereference(lun->lun_se_dev);
733 if (dev) {
734
735 ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
736 tpg->se_tpg_tfo->fabric_name);
737 }
738 rcu_read_unlock();
739 return ret;
740}
741
742static ssize_t target_stat_transport_indx_show(struct config_item *item,
743 char *page)
744{
745 struct se_lun *lun = to_transport_stat(item);
746 struct se_device *dev;
747 struct se_portal_group *tpg = lun->lun_tpg;
748 ssize_t ret = -ENODEV;
749
750 rcu_read_lock();
751 dev = rcu_dereference(lun->lun_se_dev);
752 if (dev)
753 ret = snprintf(page, PAGE_SIZE, "%u\n",
754 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
755 rcu_read_unlock();
756 return ret;
757}
758
759static ssize_t target_stat_transport_dev_name_show(struct config_item *item,
760 char *page)
761{
762 struct se_lun *lun = to_transport_stat(item);
763 struct se_device *dev;
764 struct se_portal_group *tpg = lun->lun_tpg;
765 struct t10_wwn *wwn;
766 ssize_t ret = -ENODEV;
767
768 rcu_read_lock();
769 dev = rcu_dereference(lun->lun_se_dev);
770 if (dev) {
771 wwn = &dev->t10_wwn;
772
773 ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
774 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
775 (strlen(wwn->unit_serial)) ? wwn->unit_serial :
776 wwn->vendor);
777 }
778 rcu_read_unlock();
779 return ret;
780}
781
782static ssize_t target_stat_transport_proto_id_show(struct config_item *item,
783 char *page)
784{
785 struct se_lun *lun = to_transport_stat(item);
786 struct se_device *dev;
787 struct se_portal_group *tpg = lun->lun_tpg;
788 ssize_t ret = -ENODEV;
789
790 rcu_read_lock();
791 dev = rcu_dereference(lun->lun_se_dev);
792 if (dev)
793 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->proto_id);
794 rcu_read_unlock();
795 return ret;
796}
797
798CONFIGFS_ATTR_RO(target_stat_transport_, inst);
799CONFIGFS_ATTR_RO(target_stat_transport_, device);
800CONFIGFS_ATTR_RO(target_stat_transport_, indx);
801CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
802CONFIGFS_ATTR_RO(target_stat_transport_, proto_id);
803
804static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
805 &target_stat_transport_attr_inst,
806 &target_stat_transport_attr_device,
807 &target_stat_transport_attr_indx,
808 &target_stat_transport_attr_dev_name,
809 &target_stat_transport_attr_proto_id,
810 NULL,
811};
812
813static const struct config_item_type target_stat_scsi_transport_cit = {
814 .ct_attrs = target_stat_scsi_transport_attrs,
815 .ct_owner = THIS_MODULE,
816};
817
818
819
820
821
822void target_stat_setup_port_default_groups(struct se_lun *lun)
823{
824 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
825 "scsi_port", &target_stat_scsi_port_cit);
826 configfs_add_default_group(&lun->port_stat_grps.scsi_port_group,
827 &lun->port_stat_grps.stat_group);
828
829 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
830 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
831 configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group,
832 &lun->port_stat_grps.stat_group);
833
834 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
835 "scsi_transport", &target_stat_scsi_transport_cit);
836 configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group,
837 &lun->port_stat_grps.stat_group);
838}
839
840
841
842
843
844static struct se_lun_acl *auth_to_lacl(struct config_item *item)
845{
846 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
847 struct se_ml_stat_grps, scsi_auth_intr_group);
848 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
849}
850
851static ssize_t target_stat_auth_inst_show(struct config_item *item,
852 char *page)
853{
854 struct se_lun_acl *lacl = auth_to_lacl(item);
855 struct se_node_acl *nacl = lacl->se_lun_nacl;
856 struct se_dev_entry *deve;
857 struct se_portal_group *tpg;
858 ssize_t ret;
859
860 rcu_read_lock();
861 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
862 if (!deve) {
863 rcu_read_unlock();
864 return -ENODEV;
865 }
866 tpg = nacl->se_tpg;
867
868 ret = snprintf(page, PAGE_SIZE, "%u\n",
869 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
870 rcu_read_unlock();
871 return ret;
872}
873
874static ssize_t target_stat_auth_dev_show(struct config_item *item,
875 char *page)
876{
877 struct se_lun_acl *lacl = auth_to_lacl(item);
878 struct se_node_acl *nacl = lacl->se_lun_nacl;
879 struct se_dev_entry *deve;
880 struct se_lun *lun;
881 ssize_t ret;
882
883 rcu_read_lock();
884 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
885 if (!deve) {
886 rcu_read_unlock();
887 return -ENODEV;
888 }
889 lun = rcu_dereference(deve->se_lun);
890
891 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
892 rcu_read_unlock();
893 return ret;
894}
895
896static ssize_t target_stat_auth_port_show(struct config_item *item,
897 char *page)
898{
899 struct se_lun_acl *lacl = auth_to_lacl(item);
900 struct se_node_acl *nacl = lacl->se_lun_nacl;
901 struct se_dev_entry *deve;
902 struct se_portal_group *tpg;
903 ssize_t ret;
904
905 rcu_read_lock();
906 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
907 if (!deve) {
908 rcu_read_unlock();
909 return -ENODEV;
910 }
911 tpg = nacl->se_tpg;
912
913 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
914 rcu_read_unlock();
915 return ret;
916}
917
918static ssize_t target_stat_auth_indx_show(struct config_item *item,
919 char *page)
920{
921 struct se_lun_acl *lacl = auth_to_lacl(item);
922 struct se_node_acl *nacl = lacl->se_lun_nacl;
923 struct se_dev_entry *deve;
924 ssize_t ret;
925
926 rcu_read_lock();
927 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
928 if (!deve) {
929 rcu_read_unlock();
930 return -ENODEV;
931 }
932
933 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
934 rcu_read_unlock();
935 return ret;
936}
937
938static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
939 char *page)
940{
941 struct se_lun_acl *lacl = auth_to_lacl(item);
942 struct se_node_acl *nacl = lacl->se_lun_nacl;
943 struct se_dev_entry *deve;
944 ssize_t ret;
945
946 rcu_read_lock();
947 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
948 if (!deve) {
949 rcu_read_unlock();
950 return -ENODEV;
951 }
952
953 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
954 rcu_read_unlock();
955 return ret;
956}
957
958static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
959 char *page)
960{
961 struct se_lun_acl *lacl = auth_to_lacl(item);
962 struct se_node_acl *nacl = lacl->se_lun_nacl;
963 struct se_dev_entry *deve;
964 ssize_t ret;
965
966 rcu_read_lock();
967 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
968 if (!deve) {
969 rcu_read_unlock();
970 return -ENODEV;
971 }
972
973 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
974 rcu_read_unlock();
975 return ret;
976}
977
978static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
979 char *page)
980{
981 struct se_lun_acl *lacl = auth_to_lacl(item);
982 struct se_node_acl *nacl = lacl->se_lun_nacl;
983 struct se_dev_entry *deve;
984 ssize_t ret;
985
986 rcu_read_lock();
987 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
988 if (!deve) {
989 rcu_read_unlock();
990 return -ENODEV;
991 }
992
993 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
994 rcu_read_unlock();
995 return ret;
996}
997
998static ssize_t target_stat_auth_att_count_show(struct config_item *item,
999 char *page)
1000{
1001 struct se_lun_acl *lacl = auth_to_lacl(item);
1002 struct se_node_acl *nacl = lacl->se_lun_nacl;
1003 struct se_dev_entry *deve;
1004 ssize_t ret;
1005
1006 rcu_read_lock();
1007 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1008 if (!deve) {
1009 rcu_read_unlock();
1010 return -ENODEV;
1011 }
1012
1013 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1014 rcu_read_unlock();
1015 return ret;
1016}
1017
1018static ssize_t target_stat_auth_num_cmds_show(struct config_item *item,
1019 char *page)
1020{
1021 struct se_lun_acl *lacl = auth_to_lacl(item);
1022 struct se_node_acl *nacl = lacl->se_lun_nacl;
1023 struct se_dev_entry *deve;
1024 ssize_t ret;
1025
1026 rcu_read_lock();
1027 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1028 if (!deve) {
1029 rcu_read_unlock();
1030 return -ENODEV;
1031 }
1032
1033 ret = snprintf(page, PAGE_SIZE, "%lu\n",
1034 atomic_long_read(&deve->total_cmds));
1035 rcu_read_unlock();
1036 return ret;
1037}
1038
1039static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item,
1040 char *page)
1041{
1042 struct se_lun_acl *lacl = auth_to_lacl(item);
1043 struct se_node_acl *nacl = lacl->se_lun_nacl;
1044 struct se_dev_entry *deve;
1045 ssize_t ret;
1046
1047 rcu_read_lock();
1048 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1049 if (!deve) {
1050 rcu_read_unlock();
1051 return -ENODEV;
1052 }
1053
1054 ret = snprintf(page, PAGE_SIZE, "%u\n",
1055 (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1056 rcu_read_unlock();
1057 return ret;
1058}
1059
1060static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item,
1061 char *page)
1062{
1063 struct se_lun_acl *lacl = auth_to_lacl(item);
1064 struct se_node_acl *nacl = lacl->se_lun_nacl;
1065 struct se_dev_entry *deve;
1066 ssize_t ret;
1067
1068 rcu_read_lock();
1069 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1070 if (!deve) {
1071 rcu_read_unlock();
1072 return -ENODEV;
1073 }
1074
1075 ret = snprintf(page, PAGE_SIZE, "%u\n",
1076 (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1077 rcu_read_unlock();
1078 return ret;
1079}
1080
1081static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1082 char *page)
1083{
1084 struct se_lun_acl *lacl = auth_to_lacl(item);
1085 struct se_node_acl *nacl = lacl->se_lun_nacl;
1086 struct se_dev_entry *deve;
1087 ssize_t ret;
1088
1089 rcu_read_lock();
1090 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1091 if (!deve) {
1092 rcu_read_unlock();
1093 return -ENODEV;
1094 }
1095
1096 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1097 rcu_read_unlock();
1098 return ret;
1099}
1100
1101static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1102 char *page)
1103{
1104 struct se_lun_acl *lacl = auth_to_lacl(item);
1105 struct se_node_acl *nacl = lacl->se_lun_nacl;
1106 struct se_dev_entry *deve;
1107 ssize_t ret;
1108
1109 rcu_read_lock();
1110 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1111 if (!deve) {
1112 rcu_read_unlock();
1113 return -ENODEV;
1114 }
1115
1116 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1117 INITIAL_JIFFIES) * 100 / HZ));
1118 rcu_read_unlock();
1119 return ret;
1120}
1121
1122static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1123 char *page)
1124{
1125 struct se_lun_acl *lacl = auth_to_lacl(item);
1126 struct se_node_acl *nacl = lacl->se_lun_nacl;
1127 struct se_dev_entry *deve;
1128 ssize_t ret;
1129
1130 rcu_read_lock();
1131 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1132 if (!deve) {
1133 rcu_read_unlock();
1134 return -ENODEV;
1135 }
1136
1137 ret = snprintf(page, PAGE_SIZE, "Ready\n");
1138 rcu_read_unlock();
1139 return ret;
1140}
1141
1142CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1143CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1144CONFIGFS_ATTR_RO(target_stat_auth_, port);
1145CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1146CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1147CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1148CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1149CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1150CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1151CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1152CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1153CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1154CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1155CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1156
1157static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1158 &target_stat_auth_attr_inst,
1159 &target_stat_auth_attr_dev,
1160 &target_stat_auth_attr_port,
1161 &target_stat_auth_attr_indx,
1162 &target_stat_auth_attr_dev_or_port,
1163 &target_stat_auth_attr_intr_name,
1164 &target_stat_auth_attr_map_indx,
1165 &target_stat_auth_attr_att_count,
1166 &target_stat_auth_attr_num_cmds,
1167 &target_stat_auth_attr_read_mbytes,
1168 &target_stat_auth_attr_write_mbytes,
1169 &target_stat_auth_attr_hs_num_cmds,
1170 &target_stat_auth_attr_creation_time,
1171 &target_stat_auth_attr_row_status,
1172 NULL,
1173};
1174
1175static const struct config_item_type target_stat_scsi_auth_intr_cit = {
1176 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1177 .ct_owner = THIS_MODULE,
1178};
1179
1180
1181
1182
1183
1184static struct se_lun_acl *iport_to_lacl(struct config_item *item)
1185{
1186 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1187 struct se_ml_stat_grps, scsi_att_intr_port_group);
1188 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1189}
1190
1191static ssize_t target_stat_iport_inst_show(struct config_item *item,
1192 char *page)
1193{
1194 struct se_lun_acl *lacl = iport_to_lacl(item);
1195 struct se_node_acl *nacl = lacl->se_lun_nacl;
1196 struct se_dev_entry *deve;
1197 struct se_portal_group *tpg;
1198 ssize_t ret;
1199
1200 rcu_read_lock();
1201 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1202 if (!deve) {
1203 rcu_read_unlock();
1204 return -ENODEV;
1205 }
1206 tpg = nacl->se_tpg;
1207
1208 ret = snprintf(page, PAGE_SIZE, "%u\n",
1209 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1210 rcu_read_unlock();
1211 return ret;
1212}
1213
1214static ssize_t target_stat_iport_dev_show(struct config_item *item,
1215 char *page)
1216{
1217 struct se_lun_acl *lacl = iport_to_lacl(item);
1218 struct se_node_acl *nacl = lacl->se_lun_nacl;
1219 struct se_dev_entry *deve;
1220 struct se_lun *lun;
1221 ssize_t ret;
1222
1223 rcu_read_lock();
1224 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1225 if (!deve) {
1226 rcu_read_unlock();
1227 return -ENODEV;
1228 }
1229 lun = rcu_dereference(deve->se_lun);
1230
1231 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1232 rcu_read_unlock();
1233 return ret;
1234}
1235
1236static ssize_t target_stat_iport_port_show(struct config_item *item,
1237 char *page)
1238{
1239 struct se_lun_acl *lacl = iport_to_lacl(item);
1240 struct se_node_acl *nacl = lacl->se_lun_nacl;
1241 struct se_dev_entry *deve;
1242 struct se_portal_group *tpg;
1243 ssize_t ret;
1244
1245 rcu_read_lock();
1246 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1247 if (!deve) {
1248 rcu_read_unlock();
1249 return -ENODEV;
1250 }
1251 tpg = nacl->se_tpg;
1252
1253 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1254 rcu_read_unlock();
1255 return ret;
1256}
1257
1258static ssize_t target_stat_iport_indx_show(struct config_item *item,
1259 char *page)
1260{
1261 struct se_lun_acl *lacl = iport_to_lacl(item);
1262 struct se_node_acl *nacl = lacl->se_lun_nacl;
1263 struct se_session *se_sess;
1264 struct se_portal_group *tpg;
1265 ssize_t ret;
1266
1267 spin_lock_irq(&nacl->nacl_sess_lock);
1268 se_sess = nacl->nacl_sess;
1269 if (!se_sess) {
1270 spin_unlock_irq(&nacl->nacl_sess_lock);
1271 return -ENODEV;
1272 }
1273
1274 tpg = nacl->se_tpg;
1275
1276 ret = snprintf(page, PAGE_SIZE, "%u\n",
1277 tpg->se_tpg_tfo->sess_get_index(se_sess));
1278 spin_unlock_irq(&nacl->nacl_sess_lock);
1279 return ret;
1280}
1281
1282static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item,
1283 char *page)
1284{
1285 struct se_lun_acl *lacl = iport_to_lacl(item);
1286 struct se_node_acl *nacl = lacl->se_lun_nacl;
1287 struct se_dev_entry *deve;
1288 ssize_t ret;
1289
1290 rcu_read_lock();
1291 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1292 if (!deve) {
1293 rcu_read_unlock();
1294 return -ENODEV;
1295 }
1296
1297 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1298 rcu_read_unlock();
1299 return ret;
1300}
1301
1302static ssize_t target_stat_iport_port_ident_show(struct config_item *item,
1303 char *page)
1304{
1305 struct se_lun_acl *lacl = iport_to_lacl(item);
1306 struct se_node_acl *nacl = lacl->se_lun_nacl;
1307 struct se_session *se_sess;
1308 struct se_portal_group *tpg;
1309 ssize_t ret;
1310 unsigned char buf[64];
1311
1312 spin_lock_irq(&nacl->nacl_sess_lock);
1313 se_sess = nacl->nacl_sess;
1314 if (!se_sess) {
1315 spin_unlock_irq(&nacl->nacl_sess_lock);
1316 return -ENODEV;
1317 }
1318
1319 tpg = nacl->se_tpg;
1320
1321 memset(buf, 0, 64);
1322 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1323 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1324
1325 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1326 spin_unlock_irq(&nacl->nacl_sess_lock);
1327 return ret;
1328}
1329
1330CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1331CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1332CONFIGFS_ATTR_RO(target_stat_iport_, port);
1333CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1334CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1335CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
1336
1337static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1338 &target_stat_iport_attr_inst,
1339 &target_stat_iport_attr_dev,
1340 &target_stat_iport_attr_port,
1341 &target_stat_iport_attr_indx,
1342 &target_stat_iport_attr_port_auth_indx,
1343 &target_stat_iport_attr_port_ident,
1344 NULL,
1345};
1346
1347static const struct config_item_type target_stat_scsi_att_intr_port_cit = {
1348 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1349 .ct_owner = THIS_MODULE,
1350};
1351
1352
1353
1354
1355
1356void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1357{
1358 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1359 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1360 configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group,
1361 &lacl->ml_stat_grps.stat_group);
1362
1363 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1364 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1365 configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1366 &lacl->ml_stat_grps.stat_group);
1367}
1368
