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