This source file includes following definitions.
- to_stat_dev
- target_stat_inst_show
- target_stat_indx_show
- target_stat_role_show
- target_stat_ports_show
- to_stat_tgt_dev
- target_stat_tgt_inst_show
- target_stat_tgt_indx_show
- target_stat_tgt_num_lus_show
- target_stat_tgt_status_show
- target_stat_tgt_non_access_lus_show
- target_stat_tgt_resets_show
- target_stat_tgt_aborts_complete_show
- target_stat_tgt_aborts_no_task_show
- to_stat_lu_dev
- target_stat_lu_inst_show
- target_stat_lu_dev_show
- target_stat_lu_indx_show
- target_stat_lu_lun_show
- target_stat_lu_lu_name_show
- target_stat_lu_vend_show
- target_stat_lu_prod_show
- target_stat_lu_rev_show
- target_stat_lu_dev_type_show
- target_stat_lu_status_show
- target_stat_lu_state_bit_show
- target_stat_lu_num_cmds_show
- target_stat_lu_read_mbytes_show
- target_stat_lu_write_mbytes_show
- target_stat_lu_resets_show
- target_stat_lu_full_stat_show
- target_stat_lu_hs_num_cmds_show
- target_stat_lu_creation_time_show
- target_stat_setup_dev_default_groups
- to_stat_port
- target_stat_port_inst_show
- target_stat_port_dev_show
- target_stat_port_indx_show
- target_stat_port_role_show
- target_stat_port_busy_count_show
- to_stat_tgt_port
- target_stat_tgt_port_inst_show
- target_stat_tgt_port_dev_show
- target_stat_tgt_port_indx_show
- target_stat_tgt_port_name_show
- target_stat_tgt_port_port_index_show
- target_stat_tgt_port_in_cmds_show
- target_stat_tgt_port_write_mbytes_show
- target_stat_tgt_port_read_mbytes_show
- target_stat_tgt_port_hs_in_cmds_show
- to_transport_stat
- target_stat_transport_inst_show
- target_stat_transport_device_show
- target_stat_transport_indx_show
- target_stat_transport_dev_name_show
- target_stat_transport_proto_id_show
- target_stat_setup_port_default_groups
- auth_to_lacl
- target_stat_auth_inst_show
- target_stat_auth_dev_show
- target_stat_auth_port_show
- target_stat_auth_indx_show
- target_stat_auth_dev_or_port_show
- target_stat_auth_intr_name_show
- target_stat_auth_map_indx_show
- target_stat_auth_att_count_show
- target_stat_auth_num_cmds_show
- target_stat_auth_read_mbytes_show
- target_stat_auth_write_mbytes_show
- target_stat_auth_hs_num_cmds_show
- target_stat_auth_creation_time_show
- target_stat_auth_row_status_show
- iport_to_lacl
- target_stat_iport_inst_show
- target_stat_iport_dev_show
- target_stat_iport_port_show
- target_stat_iport_indx_show
- target_stat_iport_port_auth_indx_show
- target_stat_iport_port_ident_show
- target_stat_setup_mappedlun_default_groups
1
2
3
4
5
6
7
8
9
10
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
393
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
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
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
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
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
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
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
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
823
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
1357
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 }