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 const 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
161static ssize_t target_stat_tgt_aborts_complete_show(struct config_item *item,
162 char *page)
163{
164 return snprintf(page, PAGE_SIZE, "%lu\n",
165 atomic_long_read(&to_stat_tgt_dev(item)->aborts_complete));
166}
167
168static ssize_t target_stat_tgt_aborts_no_task_show(struct config_item *item,
169 char *page)
170{
171 return snprintf(page, PAGE_SIZE, "%lu\n",
172 atomic_long_read(&to_stat_tgt_dev(item)->aborts_no_task));
173}
174
175CONFIGFS_ATTR_RO(target_stat_tgt_, inst);
176CONFIGFS_ATTR_RO(target_stat_tgt_, indx);
177CONFIGFS_ATTR_RO(target_stat_tgt_, num_lus);
178CONFIGFS_ATTR_RO(target_stat_tgt_, status);
179CONFIGFS_ATTR_RO(target_stat_tgt_, non_access_lus);
180CONFIGFS_ATTR_RO(target_stat_tgt_, resets);
181CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_complete);
182CONFIGFS_ATTR_RO(target_stat_tgt_, aborts_no_task);
183
184static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
185 &target_stat_tgt_attr_inst,
186 &target_stat_tgt_attr_indx,
187 &target_stat_tgt_attr_num_lus,
188 &target_stat_tgt_attr_status,
189 &target_stat_tgt_attr_non_access_lus,
190 &target_stat_tgt_attr_resets,
191 &target_stat_tgt_attr_aborts_complete,
192 &target_stat_tgt_attr_aborts_no_task,
193 NULL,
194};
195
196static const struct config_item_type target_stat_scsi_tgt_dev_cit = {
197 .ct_attrs = target_stat_scsi_tgt_dev_attrs,
198 .ct_owner = THIS_MODULE,
199};
200
201/*
202 * SCSI Logical Unit Table
203 */
204
205static struct se_device *to_stat_lu_dev(struct config_item *item)
206{
207 struct se_dev_stat_grps *sgrps = container_of(to_config_group(item),
208 struct se_dev_stat_grps, scsi_lu_group);
209 return container_of(sgrps, struct se_device, dev_stat_grps);
210}
211
212static ssize_t target_stat_lu_inst_show(struct config_item *item, char *page)
213{
214 struct se_hba *hba = to_stat_lu_dev(item)->se_hba;
215
216 return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
217}
218
219static ssize_t target_stat_lu_dev_show(struct config_item *item, char *page)
220{
221 return snprintf(page, PAGE_SIZE, "%u\n",
222 to_stat_lu_dev(item)->dev_index);
223}
224
225static ssize_t target_stat_lu_indx_show(struct config_item *item, char *page)
226{
227 return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
228}
229
230static ssize_t target_stat_lu_lun_show(struct config_item *item, char *page)
231{
232 /* FIXME: scsiLuDefaultLun */
233 return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
234}
235
236static ssize_t target_stat_lu_lu_name_show(struct config_item *item, char *page)
237{
238 struct se_device *dev = to_stat_lu_dev(item);
239
240 /* scsiLuWwnName */
241 return snprintf(page, PAGE_SIZE, "%s\n",
242 (strlen(dev->t10_wwn.unit_serial)) ?
243 dev->t10_wwn.unit_serial : "None");
244}
245
246static ssize_t target_stat_lu_vend_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_VENDOR_LEN)
251 "s\n", dev->t10_wwn.vendor);
252}
253
254static ssize_t target_stat_lu_prod_show(struct config_item *item, char *page)
255{
256 struct se_device *dev = to_stat_lu_dev(item);
257
258 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_MODEL_LEN)
259 "s\n", dev->t10_wwn.model);
260}
261
262static ssize_t target_stat_lu_rev_show(struct config_item *item, char *page)
263{
264 struct se_device *dev = to_stat_lu_dev(item);
265
266 return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_REVISION_LEN)
267 "s\n", dev->t10_wwn.revision);
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 const 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 const 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->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 const 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->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
798static ssize_t target_stat_transport_proto_id_show(struct config_item *item,
799 char *page)
800{
801 struct se_lun *lun = to_transport_stat(item);
802 struct se_device *dev;
803 struct se_portal_group *tpg = lun->lun_tpg;
804 ssize_t ret = -ENODEV;
805
806 rcu_read_lock();
807 dev = rcu_dereference(lun->lun_se_dev);
808 if (dev)
809 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->proto_id);
810 rcu_read_unlock();
811 return ret;
812}
813
814CONFIGFS_ATTR_RO(target_stat_transport_, inst);
815CONFIGFS_ATTR_RO(target_stat_transport_, device);
816CONFIGFS_ATTR_RO(target_stat_transport_, indx);
817CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
818CONFIGFS_ATTR_RO(target_stat_transport_, proto_id);
819
820static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
821 &target_stat_transport_attr_inst,
822 &target_stat_transport_attr_device,
823 &target_stat_transport_attr_indx,
824 &target_stat_transport_attr_dev_name,
825 &target_stat_transport_attr_proto_id,
826 NULL,
827};
828
829static const struct config_item_type target_stat_scsi_transport_cit = {
830 .ct_attrs = target_stat_scsi_transport_attrs,
831 .ct_owner = THIS_MODULE,
832};
833
834/*
835 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
836 * the target port statistics groups + configfs CITs located in target_core_stat.c
837 */
838void target_stat_setup_port_default_groups(struct se_lun *lun)
839{
840 config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
841 "scsi_port", &target_stat_scsi_port_cit);
842 configfs_add_default_group(&lun->port_stat_grps.scsi_port_group,
843 &lun->port_stat_grps.stat_group);
844
845 config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
846 "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
847 configfs_add_default_group(&lun->port_stat_grps.scsi_tgt_port_group,
848 &lun->port_stat_grps.stat_group);
849
850 config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
851 "scsi_transport", &target_stat_scsi_transport_cit);
852 configfs_add_default_group(&lun->port_stat_grps.scsi_transport_group,
853 &lun->port_stat_grps.stat_group);
854}
855
856/*
857 * SCSI Authorized Initiator Table
858 */
859
860static struct se_lun_acl *auth_to_lacl(struct config_item *item)
861{
862 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
863 struct se_ml_stat_grps, scsi_auth_intr_group);
864 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
865}
866
867static ssize_t target_stat_auth_inst_show(struct config_item *item,
868 char *page)
869{
870 struct se_lun_acl *lacl = auth_to_lacl(item);
871 struct se_node_acl *nacl = lacl->se_lun_nacl;
872 struct se_dev_entry *deve;
873 struct se_portal_group *tpg;
874 ssize_t ret;
875
876 rcu_read_lock();
877 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
878 if (!deve) {
879 rcu_read_unlock();
880 return -ENODEV;
881 }
882 tpg = nacl->se_tpg;
883 /* scsiInstIndex */
884 ret = snprintf(page, PAGE_SIZE, "%u\n",
885 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
886 rcu_read_unlock();
887 return ret;
888}
889
890static ssize_t target_stat_auth_dev_show(struct config_item *item,
891 char *page)
892{
893 struct se_lun_acl *lacl = auth_to_lacl(item);
894 struct se_node_acl *nacl = lacl->se_lun_nacl;
895 struct se_dev_entry *deve;
896 struct se_lun *lun;
897 ssize_t ret;
898
899 rcu_read_lock();
900 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
901 if (!deve) {
902 rcu_read_unlock();
903 return -ENODEV;
904 }
905 lun = rcu_dereference(deve->se_lun);
906 /* scsiDeviceIndex */
907 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
908 rcu_read_unlock();
909 return ret;
910}
911
912static ssize_t target_stat_auth_port_show(struct config_item *item,
913 char *page)
914{
915 struct se_lun_acl *lacl = auth_to_lacl(item);
916 struct se_node_acl *nacl = lacl->se_lun_nacl;
917 struct se_dev_entry *deve;
918 struct se_portal_group *tpg;
919 ssize_t ret;
920
921 rcu_read_lock();
922 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
923 if (!deve) {
924 rcu_read_unlock();
925 return -ENODEV;
926 }
927 tpg = nacl->se_tpg;
928 /* scsiAuthIntrTgtPortIndex */
929 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
930 rcu_read_unlock();
931 return ret;
932}
933
934static ssize_t target_stat_auth_indx_show(struct config_item *item,
935 char *page)
936{
937 struct se_lun_acl *lacl = auth_to_lacl(item);
938 struct se_node_acl *nacl = lacl->se_lun_nacl;
939 struct se_dev_entry *deve;
940 ssize_t ret;
941
942 rcu_read_lock();
943 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
944 if (!deve) {
945 rcu_read_unlock();
946 return -ENODEV;
947 }
948 /* scsiAuthIntrIndex */
949 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
950 rcu_read_unlock();
951 return ret;
952}
953
954static ssize_t target_stat_auth_dev_or_port_show(struct config_item *item,
955 char *page)
956{
957 struct se_lun_acl *lacl = auth_to_lacl(item);
958 struct se_node_acl *nacl = lacl->se_lun_nacl;
959 struct se_dev_entry *deve;
960 ssize_t ret;
961
962 rcu_read_lock();
963 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
964 if (!deve) {
965 rcu_read_unlock();
966 return -ENODEV;
967 }
968 /* scsiAuthIntrDevOrPort */
969 ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
970 rcu_read_unlock();
971 return ret;
972}
973
974static ssize_t target_stat_auth_intr_name_show(struct config_item *item,
975 char *page)
976{
977 struct se_lun_acl *lacl = auth_to_lacl(item);
978 struct se_node_acl *nacl = lacl->se_lun_nacl;
979 struct se_dev_entry *deve;
980 ssize_t ret;
981
982 rcu_read_lock();
983 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
984 if (!deve) {
985 rcu_read_unlock();
986 return -ENODEV;
987 }
988 /* scsiAuthIntrName */
989 ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
990 rcu_read_unlock();
991 return ret;
992}
993
994static ssize_t target_stat_auth_map_indx_show(struct config_item *item,
995 char *page)
996{
997 struct se_lun_acl *lacl = auth_to_lacl(item);
998 struct se_node_acl *nacl = lacl->se_lun_nacl;
999 struct se_dev_entry *deve;
1000 ssize_t ret;
1001
1002 rcu_read_lock();
1003 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1004 if (!deve) {
1005 rcu_read_unlock();
1006 return -ENODEV;
1007 }
1008 /* FIXME: scsiAuthIntrLunMapIndex */
1009 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1010 rcu_read_unlock();
1011 return ret;
1012}
1013
1014static ssize_t target_stat_auth_att_count_show(struct config_item *item,
1015 char *page)
1016{
1017 struct se_lun_acl *lacl = auth_to_lacl(item);
1018 struct se_node_acl *nacl = lacl->se_lun_nacl;
1019 struct se_dev_entry *deve;
1020 ssize_t ret;
1021
1022 rcu_read_lock();
1023 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1024 if (!deve) {
1025 rcu_read_unlock();
1026 return -ENODEV;
1027 }
1028 /* scsiAuthIntrAttachedTimes */
1029 ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1030 rcu_read_unlock();
1031 return ret;
1032}
1033
1034static ssize_t target_stat_auth_num_cmds_show(struct config_item *item,
1035 char *page)
1036{
1037 struct se_lun_acl *lacl = auth_to_lacl(item);
1038 struct se_node_acl *nacl = lacl->se_lun_nacl;
1039 struct se_dev_entry *deve;
1040 ssize_t ret;
1041
1042 rcu_read_lock();
1043 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1044 if (!deve) {
1045 rcu_read_unlock();
1046 return -ENODEV;
1047 }
1048 /* scsiAuthIntrOutCommands */
1049 ret = snprintf(page, PAGE_SIZE, "%lu\n",
1050 atomic_long_read(&deve->total_cmds));
1051 rcu_read_unlock();
1052 return ret;
1053}
1054
1055static ssize_t target_stat_auth_read_mbytes_show(struct config_item *item,
1056 char *page)
1057{
1058 struct se_lun_acl *lacl = auth_to_lacl(item);
1059 struct se_node_acl *nacl = lacl->se_lun_nacl;
1060 struct se_dev_entry *deve;
1061 ssize_t ret;
1062
1063 rcu_read_lock();
1064 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1065 if (!deve) {
1066 rcu_read_unlock();
1067 return -ENODEV;
1068 }
1069 /* scsiAuthIntrReadMegaBytes */
1070 ret = snprintf(page, PAGE_SIZE, "%u\n",
1071 (u32)(atomic_long_read(&deve->read_bytes) >> 20));
1072 rcu_read_unlock();
1073 return ret;
1074}
1075
1076static ssize_t target_stat_auth_write_mbytes_show(struct config_item *item,
1077 char *page)
1078{
1079 struct se_lun_acl *lacl = auth_to_lacl(item);
1080 struct se_node_acl *nacl = lacl->se_lun_nacl;
1081 struct se_dev_entry *deve;
1082 ssize_t ret;
1083
1084 rcu_read_lock();
1085 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1086 if (!deve) {
1087 rcu_read_unlock();
1088 return -ENODEV;
1089 }
1090 /* scsiAuthIntrWrittenMegaBytes */
1091 ret = snprintf(page, PAGE_SIZE, "%u\n",
1092 (u32)(atomic_long_read(&deve->write_bytes) >> 20));
1093 rcu_read_unlock();
1094 return ret;
1095}
1096
1097static ssize_t target_stat_auth_hs_num_cmds_show(struct config_item *item,
1098 char *page)
1099{
1100 struct se_lun_acl *lacl = auth_to_lacl(item);
1101 struct se_node_acl *nacl = lacl->se_lun_nacl;
1102 struct se_dev_entry *deve;
1103 ssize_t ret;
1104
1105 rcu_read_lock();
1106 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1107 if (!deve) {
1108 rcu_read_unlock();
1109 return -ENODEV;
1110 }
1111 /* FIXME: scsiAuthIntrHSOutCommands */
1112 ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1113 rcu_read_unlock();
1114 return ret;
1115}
1116
1117static ssize_t target_stat_auth_creation_time_show(struct config_item *item,
1118 char *page)
1119{
1120 struct se_lun_acl *lacl = auth_to_lacl(item);
1121 struct se_node_acl *nacl = lacl->se_lun_nacl;
1122 struct se_dev_entry *deve;
1123 ssize_t ret;
1124
1125 rcu_read_lock();
1126 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1127 if (!deve) {
1128 rcu_read_unlock();
1129 return -ENODEV;
1130 }
1131 /* scsiAuthIntrLastCreation */
1132 ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1133 INITIAL_JIFFIES) * 100 / HZ));
1134 rcu_read_unlock();
1135 return ret;
1136}
1137
1138static ssize_t target_stat_auth_row_status_show(struct config_item *item,
1139 char *page)
1140{
1141 struct se_lun_acl *lacl = auth_to_lacl(item);
1142 struct se_node_acl *nacl = lacl->se_lun_nacl;
1143 struct se_dev_entry *deve;
1144 ssize_t ret;
1145
1146 rcu_read_lock();
1147 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1148 if (!deve) {
1149 rcu_read_unlock();
1150 return -ENODEV;
1151 }
1152 /* FIXME: scsiAuthIntrRowStatus */
1153 ret = snprintf(page, PAGE_SIZE, "Ready\n");
1154 rcu_read_unlock();
1155 return ret;
1156}
1157
1158CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1159CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1160CONFIGFS_ATTR_RO(target_stat_auth_, port);
1161CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1162CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1163CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1164CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1165CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1166CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1167CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1168CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1169CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1170CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1171CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1172
1173static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1174 &target_stat_auth_attr_inst,
1175 &target_stat_auth_attr_dev,
1176 &target_stat_auth_attr_port,
1177 &target_stat_auth_attr_indx,
1178 &target_stat_auth_attr_dev_or_port,
1179 &target_stat_auth_attr_intr_name,
1180 &target_stat_auth_attr_map_indx,
1181 &target_stat_auth_attr_att_count,
1182 &target_stat_auth_attr_num_cmds,
1183 &target_stat_auth_attr_read_mbytes,
1184 &target_stat_auth_attr_write_mbytes,
1185 &target_stat_auth_attr_hs_num_cmds,
1186 &target_stat_auth_attr_creation_time,
1187 &target_stat_auth_attr_row_status,
1188 NULL,
1189};
1190
1191static const struct config_item_type target_stat_scsi_auth_intr_cit = {
1192 .ct_attrs = target_stat_scsi_auth_intr_attrs,
1193 .ct_owner = THIS_MODULE,
1194};
1195
1196/*
1197 * SCSI Attached Initiator Port Table
1198 */
1199
1200static struct se_lun_acl *iport_to_lacl(struct config_item *item)
1201{
1202 struct se_ml_stat_grps *lgrps = container_of(to_config_group(item),
1203 struct se_ml_stat_grps, scsi_att_intr_port_group);
1204 return container_of(lgrps, struct se_lun_acl, ml_stat_grps);
1205}
1206
1207static ssize_t target_stat_iport_inst_show(struct config_item *item,
1208 char *page)
1209{
1210 struct se_lun_acl *lacl = iport_to_lacl(item);
1211 struct se_node_acl *nacl = lacl->se_lun_nacl;
1212 struct se_dev_entry *deve;
1213 struct se_portal_group *tpg;
1214 ssize_t ret;
1215
1216 rcu_read_lock();
1217 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1218 if (!deve) {
1219 rcu_read_unlock();
1220 return -ENODEV;
1221 }
1222 tpg = nacl->se_tpg;
1223 /* scsiInstIndex */
1224 ret = snprintf(page, PAGE_SIZE, "%u\n",
1225 tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1226 rcu_read_unlock();
1227 return ret;
1228}
1229
1230static ssize_t target_stat_iport_dev_show(struct config_item *item,
1231 char *page)
1232{
1233 struct se_lun_acl *lacl = iport_to_lacl(item);
1234 struct se_node_acl *nacl = lacl->se_lun_nacl;
1235 struct se_dev_entry *deve;
1236 struct se_lun *lun;
1237 ssize_t ret;
1238
1239 rcu_read_lock();
1240 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1241 if (!deve) {
1242 rcu_read_unlock();
1243 return -ENODEV;
1244 }
1245 lun = rcu_dereference(deve->se_lun);
1246 /* scsiDeviceIndex */
1247 ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_index);
1248 rcu_read_unlock();
1249 return ret;
1250}
1251
1252static ssize_t target_stat_iport_port_show(struct config_item *item,
1253 char *page)
1254{
1255 struct se_lun_acl *lacl = iport_to_lacl(item);
1256 struct se_node_acl *nacl = lacl->se_lun_nacl;
1257 struct se_dev_entry *deve;
1258 struct se_portal_group *tpg;
1259 ssize_t ret;
1260
1261 rcu_read_lock();
1262 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1263 if (!deve) {
1264 rcu_read_unlock();
1265 return -ENODEV;
1266 }
1267 tpg = nacl->se_tpg;
1268 /* scsiPortIndex */
1269 ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1270 rcu_read_unlock();
1271 return ret;
1272}
1273
1274static ssize_t target_stat_iport_indx_show(struct config_item *item,
1275 char *page)
1276{
1277 struct se_lun_acl *lacl = iport_to_lacl(item);
1278 struct se_node_acl *nacl = lacl->se_lun_nacl;
1279 struct se_session *se_sess;
1280 struct se_portal_group *tpg;
1281 ssize_t ret;
1282
1283 spin_lock_irq(&nacl->nacl_sess_lock);
1284 se_sess = nacl->nacl_sess;
1285 if (!se_sess) {
1286 spin_unlock_irq(&nacl->nacl_sess_lock);
1287 return -ENODEV;
1288 }
1289
1290 tpg = nacl->se_tpg;
1291 /* scsiAttIntrPortIndex */
1292 ret = snprintf(page, PAGE_SIZE, "%u\n",
1293 tpg->se_tpg_tfo->sess_get_index(se_sess));
1294 spin_unlock_irq(&nacl->nacl_sess_lock);
1295 return ret;
1296}
1297
1298static ssize_t target_stat_iport_port_auth_indx_show(struct config_item *item,
1299 char *page)
1300{
1301 struct se_lun_acl *lacl = iport_to_lacl(item);
1302 struct se_node_acl *nacl = lacl->se_lun_nacl;
1303 struct se_dev_entry *deve;
1304 ssize_t ret;
1305
1306 rcu_read_lock();
1307 deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
1308 if (!deve) {
1309 rcu_read_unlock();
1310 return -ENODEV;
1311 }
1312 /* scsiAttIntrPortAuthIntrIdx */
1313 ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1314 rcu_read_unlock();
1315 return ret;
1316}
1317
1318static ssize_t target_stat_iport_port_ident_show(struct config_item *item,
1319 char *page)
1320{
1321 struct se_lun_acl *lacl = iport_to_lacl(item);
1322 struct se_node_acl *nacl = lacl->se_lun_nacl;
1323 struct se_session *se_sess;
1324 struct se_portal_group *tpg;
1325 ssize_t ret;
1326 unsigned char buf[64];
1327
1328 spin_lock_irq(&nacl->nacl_sess_lock);
1329 se_sess = nacl->nacl_sess;
1330 if (!se_sess) {
1331 spin_unlock_irq(&nacl->nacl_sess_lock);
1332 return -ENODEV;
1333 }
1334
1335 tpg = nacl->se_tpg;
1336 /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1337 memset(buf, 0, 64);
1338 if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1339 tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1340
1341 ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1342 spin_unlock_irq(&nacl->nacl_sess_lock);
1343 return ret;
1344}
1345
1346CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1347CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1348CONFIGFS_ATTR_RO(target_stat_iport_, port);
1349CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1350CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1351CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
1352
1353static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1354 &target_stat_iport_attr_inst,
1355 &target_stat_iport_attr_dev,
1356 &target_stat_iport_attr_port,
1357 &target_stat_iport_attr_indx,
1358 &target_stat_iport_attr_port_auth_indx,
1359 &target_stat_iport_attr_port_ident,
1360 NULL,
1361};
1362
1363static const struct config_item_type target_stat_scsi_att_intr_port_cit = {
1364 .ct_attrs = target_stat_scsi_ath_intr_port_attrs,
1365 .ct_owner = THIS_MODULE,
1366};
1367
1368/*
1369 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1370 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1371 */
1372void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1373{
1374 config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1375 "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1376 configfs_add_default_group(&lacl->ml_stat_grps.scsi_auth_intr_group,
1377 &lacl->ml_stat_grps.stat_group);
1378
1379 config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1380 "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1381 configfs_add_default_group(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1382 &lacl->ml_stat_grps.stat_group);
1383}
1384