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