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 
250 	return snprintf(page, PAGE_SIZE, "%-" __stringify(INQUIRY_VENDOR_LEN)
251 			"s\n", dev->t10_wwn.vendor);
252 }
253 
254 static 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 
262 static 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 
270 static 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 
279 static 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 
288 static 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 
295 static 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 
305 static 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 
315 static 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 
325 static 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 
334 static 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 
341 static 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 
348 static 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 
358 CONFIGFS_ATTR_RO(target_stat_lu_, inst);
359 CONFIGFS_ATTR_RO(target_stat_lu_, dev);
360 CONFIGFS_ATTR_RO(target_stat_lu_, indx);
361 CONFIGFS_ATTR_RO(target_stat_lu_, lun);
362 CONFIGFS_ATTR_RO(target_stat_lu_, lu_name);
363 CONFIGFS_ATTR_RO(target_stat_lu_, vend);
364 CONFIGFS_ATTR_RO(target_stat_lu_, prod);
365 CONFIGFS_ATTR_RO(target_stat_lu_, rev);
366 CONFIGFS_ATTR_RO(target_stat_lu_, dev_type);
367 CONFIGFS_ATTR_RO(target_stat_lu_, status);
368 CONFIGFS_ATTR_RO(target_stat_lu_, state_bit);
369 CONFIGFS_ATTR_RO(target_stat_lu_, num_cmds);
370 CONFIGFS_ATTR_RO(target_stat_lu_, read_mbytes);
371 CONFIGFS_ATTR_RO(target_stat_lu_, write_mbytes);
372 CONFIGFS_ATTR_RO(target_stat_lu_, resets);
373 CONFIGFS_ATTR_RO(target_stat_lu_, full_stat);
374 CONFIGFS_ATTR_RO(target_stat_lu_, hs_num_cmds);
375 CONFIGFS_ATTR_RO(target_stat_lu_, creation_time);
376 
377 static 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 
399 static 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  */
408 void 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 
430 static 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 
437 static 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 
451 static 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 
465 static 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 
479 static 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 
493 static 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 
510 CONFIGFS_ATTR_RO(target_stat_port_, inst);
511 CONFIGFS_ATTR_RO(target_stat_port_, dev);
512 CONFIGFS_ATTR_RO(target_stat_port_, indx);
513 CONFIGFS_ATTR_RO(target_stat_port_, role);
514 CONFIGFS_ATTR_RO(target_stat_port_, busy_count);
515 
516 static 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 
525 static 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  */
533 static 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 
540 static 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 
555 static 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 
570 static 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 
585 static 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 
603 static 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 
621 static 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 
637 static 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 
653 static 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 
669 static 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 
686 CONFIGFS_ATTR_RO(target_stat_tgt_port_, inst);
687 CONFIGFS_ATTR_RO(target_stat_tgt_port_, dev);
688 CONFIGFS_ATTR_RO(target_stat_tgt_port_, indx);
689 CONFIGFS_ATTR_RO(target_stat_tgt_port_, name);
690 CONFIGFS_ATTR_RO(target_stat_tgt_port_, port_index);
691 CONFIGFS_ATTR_RO(target_stat_tgt_port_, in_cmds);
692 CONFIGFS_ATTR_RO(target_stat_tgt_port_, write_mbytes);
693 CONFIGFS_ATTR_RO(target_stat_tgt_port_, read_mbytes);
694 CONFIGFS_ATTR_RO(target_stat_tgt_port_, hs_in_cmds);
695 
696 static 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 
709 static 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  */
717 static 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 
724 static 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 
739 static 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 
758 static 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 
775 static 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 
798 static 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 
814 CONFIGFS_ATTR_RO(target_stat_transport_, inst);
815 CONFIGFS_ATTR_RO(target_stat_transport_, device);
816 CONFIGFS_ATTR_RO(target_stat_transport_, indx);
817 CONFIGFS_ATTR_RO(target_stat_transport_, dev_name);
818 CONFIGFS_ATTR_RO(target_stat_transport_, proto_id);
819 
820 static 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 
829 static 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  */
838 void 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 
860 static 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 
867 static 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 
890 static 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 
912 static 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 
934 static 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 
954 static 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 
974 static 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 
994 static 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 
1014 static 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 
1034 static 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 
1055 static 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 
1076 static 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 
1097 static 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 
1117 static 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 
1138 static 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 
1158 CONFIGFS_ATTR_RO(target_stat_auth_, inst);
1159 CONFIGFS_ATTR_RO(target_stat_auth_, dev);
1160 CONFIGFS_ATTR_RO(target_stat_auth_, port);
1161 CONFIGFS_ATTR_RO(target_stat_auth_, indx);
1162 CONFIGFS_ATTR_RO(target_stat_auth_, dev_or_port);
1163 CONFIGFS_ATTR_RO(target_stat_auth_, intr_name);
1164 CONFIGFS_ATTR_RO(target_stat_auth_, map_indx);
1165 CONFIGFS_ATTR_RO(target_stat_auth_, att_count);
1166 CONFIGFS_ATTR_RO(target_stat_auth_, num_cmds);
1167 CONFIGFS_ATTR_RO(target_stat_auth_, read_mbytes);
1168 CONFIGFS_ATTR_RO(target_stat_auth_, write_mbytes);
1169 CONFIGFS_ATTR_RO(target_stat_auth_, hs_num_cmds);
1170 CONFIGFS_ATTR_RO(target_stat_auth_, creation_time);
1171 CONFIGFS_ATTR_RO(target_stat_auth_, row_status);
1172 
1173 static 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 
1191 static 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 
1200 static 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 
1207 static 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 
1230 static 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 
1252 static 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 
1274 static 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 
1298 static 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 
1318 static 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 
1346 CONFIGFS_ATTR_RO(target_stat_iport_, inst);
1347 CONFIGFS_ATTR_RO(target_stat_iport_, dev);
1348 CONFIGFS_ATTR_RO(target_stat_iport_, port);
1349 CONFIGFS_ATTR_RO(target_stat_iport_, indx);
1350 CONFIGFS_ATTR_RO(target_stat_iport_, port_auth_indx);
1351 CONFIGFS_ATTR_RO(target_stat_iport_, port_ident);
1352 
1353 static 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 
1363 static 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  */
1372 void 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