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