GNU Linux-libre 4.19.263-gnu1
[releases.git] / drivers / target / iscsi / iscsi_target_stat.c
1 /*******************************************************************************
2  * Modern ConfigFS group context specific iSCSI statistics based on original
3  * iscsi_target_mib.c code
4  *
5  * Copyright (c) 2011-2013 Datera, Inc.
6  *
7  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  ******************************************************************************/
19
20 #include <linux/configfs.h>
21 #include <linux/export.h>
22 #include <scsi/iscsi_proto.h>
23 #include <target/target_core_base.h>
24
25 #include <target/iscsi/iscsi_target_core.h>
26 #include "iscsi_target_parameters.h"
27 #include "iscsi_target_device.h"
28 #include "iscsi_target_tpg.h"
29 #include "iscsi_target_util.h"
30 #include <target/iscsi/iscsi_target_stat.h>
31
32 #ifndef INITIAL_JIFFIES
33 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
34 #endif
35
36 /* Instance Attributes Table */
37 #define ISCSI_INST_NUM_NODES            1
38 #define ISCSI_INST_DESCR                "Storage Engine Target"
39 #define ISCSI_INST_LAST_FAILURE_TYPE    0
40 #define ISCSI_DISCONTINUITY_TIME        0
41
42 #define ISCSI_NODE_INDEX                1
43
44 #define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
45
46 /****************************************************************************
47  * iSCSI MIB Tables
48  ****************************************************************************/
49 /*
50  * Instance Attributes Table
51  */
52 static struct iscsi_tiqn *iscsi_instance_tiqn(struct config_item *item)
53 {
54         struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
55                         struct iscsi_wwn_stat_grps, iscsi_instance_group);
56         return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
57 }
58
59 static ssize_t iscsi_stat_instance_inst_show(struct config_item *item,
60                 char *page)
61 {
62         return snprintf(page, PAGE_SIZE, "%u\n",
63                         iscsi_instance_tiqn(item)->tiqn_index);
64 }
65
66 static ssize_t iscsi_stat_instance_min_ver_show(struct config_item *item,
67                 char *page)
68 {
69         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
70 }
71
72 static ssize_t iscsi_stat_instance_max_ver_show(struct config_item *item,
73                 char *page)
74 {
75         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
76 }
77
78 static ssize_t iscsi_stat_instance_portals_show(struct config_item *item,
79                 char *page)
80 {
81         return snprintf(page, PAGE_SIZE, "%u\n",
82                         iscsi_instance_tiqn(item)->tiqn_num_tpg_nps);
83 }
84
85 static ssize_t iscsi_stat_instance_nodes_show(struct config_item *item,
86                 char *page)
87 {
88         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_INST_NUM_NODES);
89 }
90
91 static ssize_t iscsi_stat_instance_sessions_show(struct config_item *item,
92                 char *page)
93 {
94         return snprintf(page, PAGE_SIZE, "%u\n",
95                 iscsi_instance_tiqn(item)->tiqn_nsessions);
96 }
97
98 static ssize_t iscsi_stat_instance_fail_sess_show(struct config_item *item,
99                 char *page)
100 {
101         struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
102         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
103         u32 sess_err_count;
104
105         spin_lock_bh(&sess_err->lock);
106         sess_err_count = (sess_err->digest_errors +
107                           sess_err->cxn_timeout_errors +
108                           sess_err->pdu_format_errors);
109         spin_unlock_bh(&sess_err->lock);
110
111         return snprintf(page, PAGE_SIZE, "%u\n", sess_err_count);
112 }
113
114 static ssize_t iscsi_stat_instance_fail_type_show(struct config_item *item,
115                 char *page)
116 {
117         struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
118         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
119
120         return snprintf(page, PAGE_SIZE, "%u\n",
121                         sess_err->last_sess_failure_type);
122 }
123
124 static ssize_t iscsi_stat_instance_fail_rem_name_show(struct config_item *item,
125                 char *page)
126 {
127         struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
128         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
129
130         return snprintf(page, PAGE_SIZE, "%s\n",
131                         sess_err->last_sess_fail_rem_name[0] ?
132                         sess_err->last_sess_fail_rem_name : NONE);
133 }
134
135 static ssize_t iscsi_stat_instance_disc_time_show(struct config_item *item,
136                 char *page)
137 {
138         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DISCONTINUITY_TIME);
139 }
140
141 static ssize_t iscsi_stat_instance_description_show(struct config_item *item,
142                 char *page)
143 {
144         return snprintf(page, PAGE_SIZE, "%s\n", ISCSI_INST_DESCR);
145 }
146
147 static ssize_t iscsi_stat_instance_vendor_show(struct config_item *item,
148                 char *page)
149 {
150         return snprintf(page, PAGE_SIZE, "Datera, Inc. iSCSI-Target\n");
151 }
152
153 static ssize_t iscsi_stat_instance_version_show(struct config_item *item,
154                 char *page)
155 {
156         return snprintf(page, PAGE_SIZE, "%s\n", ISCSIT_VERSION);
157 }
158
159 CONFIGFS_ATTR_RO(iscsi_stat_instance_, inst);
160 CONFIGFS_ATTR_RO(iscsi_stat_instance_, min_ver);
161 CONFIGFS_ATTR_RO(iscsi_stat_instance_, max_ver);
162 CONFIGFS_ATTR_RO(iscsi_stat_instance_, portals);
163 CONFIGFS_ATTR_RO(iscsi_stat_instance_, nodes);
164 CONFIGFS_ATTR_RO(iscsi_stat_instance_, sessions);
165 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_sess);
166 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_type);
167 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_rem_name);
168 CONFIGFS_ATTR_RO(iscsi_stat_instance_, disc_time);
169 CONFIGFS_ATTR_RO(iscsi_stat_instance_, description);
170 CONFIGFS_ATTR_RO(iscsi_stat_instance_, vendor);
171 CONFIGFS_ATTR_RO(iscsi_stat_instance_, version);
172
173 static struct configfs_attribute *iscsi_stat_instance_attrs[] = {
174         &iscsi_stat_instance_attr_inst,
175         &iscsi_stat_instance_attr_min_ver,
176         &iscsi_stat_instance_attr_max_ver,
177         &iscsi_stat_instance_attr_portals,
178         &iscsi_stat_instance_attr_nodes,
179         &iscsi_stat_instance_attr_sessions,
180         &iscsi_stat_instance_attr_fail_sess,
181         &iscsi_stat_instance_attr_fail_type,
182         &iscsi_stat_instance_attr_fail_rem_name,
183         &iscsi_stat_instance_attr_disc_time,
184         &iscsi_stat_instance_attr_description,
185         &iscsi_stat_instance_attr_vendor,
186         &iscsi_stat_instance_attr_version,
187         NULL,
188 };
189
190 const struct config_item_type iscsi_stat_instance_cit = {
191         .ct_attrs               = iscsi_stat_instance_attrs,
192         .ct_owner               = THIS_MODULE,
193 };
194
195 /*
196  * Instance Session Failure Stats Table
197  */
198 static struct iscsi_tiqn *iscsi_sess_err_tiqn(struct config_item *item)
199 {
200         struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
201                         struct iscsi_wwn_stat_grps, iscsi_sess_err_group);
202         return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
203 }
204
205 static ssize_t iscsi_stat_sess_err_inst_show(struct config_item *item,
206                 char *page)
207 {
208         return snprintf(page, PAGE_SIZE, "%u\n",
209                 iscsi_sess_err_tiqn(item)->tiqn_index);
210 }
211
212 static ssize_t iscsi_stat_sess_err_digest_errors_show(struct config_item *item,
213                 char *page)
214 {
215         struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
216         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
217
218         return snprintf(page, PAGE_SIZE, "%u\n", sess_err->digest_errors);
219 }
220
221 static ssize_t iscsi_stat_sess_err_cxn_errors_show(struct config_item *item,
222                 char *page)
223 {
224         struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
225         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
226
227         return snprintf(page, PAGE_SIZE, "%u\n", sess_err->cxn_timeout_errors);
228 }
229
230 static ssize_t iscsi_stat_sess_err_format_errors_show(struct config_item *item,
231                 char *page)
232 {
233         struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
234         struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
235
236         return snprintf(page, PAGE_SIZE, "%u\n", sess_err->pdu_format_errors);
237 }
238
239 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, inst);
240 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, digest_errors);
241 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, cxn_errors);
242 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, format_errors);
243
244 static struct configfs_attribute *iscsi_stat_sess_err_attrs[] = {
245         &iscsi_stat_sess_err_attr_inst,
246         &iscsi_stat_sess_err_attr_digest_errors,
247         &iscsi_stat_sess_err_attr_cxn_errors,
248         &iscsi_stat_sess_err_attr_format_errors,
249         NULL,
250 };
251
252 const struct config_item_type iscsi_stat_sess_err_cit = {
253         .ct_attrs               = iscsi_stat_sess_err_attrs,
254         .ct_owner               = THIS_MODULE,
255 };
256
257 /*
258  * Target Attributes Table
259  */
260 static struct iscsi_tiqn *iscsi_tgt_attr_tiqn(struct config_item *item)
261 {
262         struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
263                         struct iscsi_wwn_stat_grps, iscsi_tgt_attr_group);
264         return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
265 }
266
267 static ssize_t iscsi_stat_tgt_attr_inst_show(struct config_item *item,
268                 char *page)
269 {
270         return snprintf(page, PAGE_SIZE, "%u\n",
271                         iscsi_tgt_attr_tiqn(item)->tiqn_index);
272 }
273
274 static ssize_t iscsi_stat_tgt_attr_indx_show(struct config_item *item,
275                 char *page)
276 {
277         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
278 }
279
280 static ssize_t iscsi_stat_tgt_attr_login_fails_show(struct config_item *item,
281                 char *page)
282 {
283         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
284         struct iscsi_login_stats *lstat = &tiqn->login_stats;
285         u32 fail_count;
286
287         spin_lock(&lstat->lock);
288         fail_count = (lstat->redirects + lstat->authorize_fails +
289                         lstat->authenticate_fails + lstat->negotiate_fails +
290                         lstat->other_fails);
291         spin_unlock(&lstat->lock);
292
293         return snprintf(page, PAGE_SIZE, "%u\n", fail_count);
294 }
295
296 static ssize_t iscsi_stat_tgt_attr_last_fail_time_show(struct config_item *item,
297                 char *page)
298 {
299         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
300         struct iscsi_login_stats *lstat = &tiqn->login_stats;
301         u32 last_fail_time;
302
303         spin_lock(&lstat->lock);
304         last_fail_time = lstat->last_fail_time ?
305                         (u32)(((u32)lstat->last_fail_time -
306                                 INITIAL_JIFFIES) * 100 / HZ) : 0;
307         spin_unlock(&lstat->lock);
308
309         return snprintf(page, PAGE_SIZE, "%u\n", last_fail_time);
310 }
311
312 static ssize_t iscsi_stat_tgt_attr_last_fail_type_show(struct config_item *item,
313                 char *page)
314 {
315         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
316         struct iscsi_login_stats *lstat = &tiqn->login_stats;
317         u32 last_fail_type;
318
319         spin_lock(&lstat->lock);
320         last_fail_type = lstat->last_fail_type;
321         spin_unlock(&lstat->lock);
322
323         return snprintf(page, PAGE_SIZE, "%u\n", last_fail_type);
324 }
325
326 static ssize_t iscsi_stat_tgt_attr_fail_intr_name_show(struct config_item *item,
327                 char *page)
328 {
329         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
330         struct iscsi_login_stats *lstat = &tiqn->login_stats;
331         unsigned char buf[224];
332
333         spin_lock(&lstat->lock);
334         snprintf(buf, 224, "%s", lstat->last_intr_fail_name[0] ?
335                                 lstat->last_intr_fail_name : NONE);
336         spin_unlock(&lstat->lock);
337
338         return snprintf(page, PAGE_SIZE, "%s\n", buf);
339 }
340
341 static ssize_t iscsi_stat_tgt_attr_fail_intr_addr_type_show(struct config_item *item,
342                 char *page)
343 {
344         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
345         struct iscsi_login_stats *lstat = &tiqn->login_stats;
346         int ret;
347
348         spin_lock(&lstat->lock);
349         if (lstat->last_intr_fail_ip_family == AF_INET6)
350                 ret = snprintf(page, PAGE_SIZE, "ipv6\n");
351         else
352                 ret = snprintf(page, PAGE_SIZE, "ipv4\n");
353         spin_unlock(&lstat->lock);
354
355         return ret;
356 }
357
358 static ssize_t iscsi_stat_tgt_attr_fail_intr_addr_show(struct config_item *item,
359                 char *page)
360 {
361         struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
362         struct iscsi_login_stats *lstat = &tiqn->login_stats;
363         int ret;
364
365         spin_lock(&lstat->lock);
366         ret = snprintf(page, PAGE_SIZE, "%pISc\n", &lstat->last_intr_fail_sockaddr);
367         spin_unlock(&lstat->lock);
368
369         return ret;
370 }
371
372 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, inst);
373 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, indx);
374 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, login_fails);
375 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, last_fail_time);
376 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, last_fail_type);
377 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_name);
378 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_addr_type);
379 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_addr);
380
381 static struct configfs_attribute *iscsi_stat_tgt_attr_attrs[] = {
382         &iscsi_stat_tgt_attr_attr_inst,
383         &iscsi_stat_tgt_attr_attr_indx,
384         &iscsi_stat_tgt_attr_attr_login_fails,
385         &iscsi_stat_tgt_attr_attr_last_fail_time,
386         &iscsi_stat_tgt_attr_attr_last_fail_type,
387         &iscsi_stat_tgt_attr_attr_fail_intr_name,
388         &iscsi_stat_tgt_attr_attr_fail_intr_addr_type,
389         &iscsi_stat_tgt_attr_attr_fail_intr_addr,
390         NULL,
391 };
392
393 const struct config_item_type iscsi_stat_tgt_attr_cit = {
394         .ct_attrs               = iscsi_stat_tgt_attr_attrs,
395         .ct_owner               = THIS_MODULE,
396 };
397
398 /*
399  * Target Login Stats Table
400  */
401 static struct iscsi_tiqn *iscsi_login_stat_tiqn(struct config_item *item)
402 {
403         struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
404                         struct iscsi_wwn_stat_grps, iscsi_login_stats_group);
405         return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
406 }
407
408 static ssize_t iscsi_stat_login_inst_show(struct config_item *item, char *page)
409 {
410         return snprintf(page, PAGE_SIZE, "%u\n",
411                 iscsi_login_stat_tiqn(item)->tiqn_index);
412 }
413
414 static ssize_t iscsi_stat_login_indx_show(struct config_item *item,
415                 char *page)
416 {
417         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
418 }
419
420 static ssize_t iscsi_stat_login_accepts_show(struct config_item *item,
421                 char *page)
422 {
423         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
424         struct iscsi_login_stats *lstat = &tiqn->login_stats;
425         ssize_t ret;
426
427         spin_lock(&lstat->lock);
428         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->accepts);
429         spin_unlock(&lstat->lock);
430
431         return ret;
432 }
433
434 static ssize_t iscsi_stat_login_other_fails_show(struct config_item *item,
435                 char *page)
436 {
437         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
438         struct iscsi_login_stats *lstat = &tiqn->login_stats;
439         ssize_t ret;
440
441         spin_lock(&lstat->lock);
442         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->other_fails);
443         spin_unlock(&lstat->lock);
444
445         return ret;
446 }
447
448 static ssize_t iscsi_stat_login_redirects_show(struct config_item *item,
449                 char *page)
450 {
451         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
452         struct iscsi_login_stats *lstat = &tiqn->login_stats;
453         ssize_t ret;
454
455         spin_lock(&lstat->lock);
456         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->redirects);
457         spin_unlock(&lstat->lock);
458
459         return ret;
460 }
461
462 static ssize_t iscsi_stat_login_authorize_fails_show(struct config_item *item,
463                 char *page)
464 {
465         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
466         struct iscsi_login_stats *lstat = &tiqn->login_stats;
467         ssize_t ret;
468
469         spin_lock(&lstat->lock);
470         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authorize_fails);
471         spin_unlock(&lstat->lock);
472
473         return ret;
474 }
475
476 static ssize_t iscsi_stat_login_authenticate_fails_show(
477                 struct config_item *item, char *page)
478 {
479         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
480         struct iscsi_login_stats *lstat = &tiqn->login_stats;
481         ssize_t ret;
482
483         spin_lock(&lstat->lock);
484         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authenticate_fails);
485         spin_unlock(&lstat->lock);
486
487         return ret;
488 }
489
490 static ssize_t iscsi_stat_login_negotiate_fails_show(struct config_item *item,
491                 char *page)
492 {
493         struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
494         struct iscsi_login_stats *lstat = &tiqn->login_stats;
495         ssize_t ret;
496
497         spin_lock(&lstat->lock);
498         ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->negotiate_fails);
499         spin_unlock(&lstat->lock);
500
501         return ret;
502 }
503
504 CONFIGFS_ATTR_RO(iscsi_stat_login_, inst);
505 CONFIGFS_ATTR_RO(iscsi_stat_login_, indx);
506 CONFIGFS_ATTR_RO(iscsi_stat_login_, accepts);
507 CONFIGFS_ATTR_RO(iscsi_stat_login_, other_fails);
508 CONFIGFS_ATTR_RO(iscsi_stat_login_, redirects);
509 CONFIGFS_ATTR_RO(iscsi_stat_login_, authorize_fails);
510 CONFIGFS_ATTR_RO(iscsi_stat_login_, authenticate_fails);
511 CONFIGFS_ATTR_RO(iscsi_stat_login_, negotiate_fails);
512
513 static struct configfs_attribute *iscsi_stat_login_stats_attrs[] = {
514         &iscsi_stat_login_attr_inst,
515         &iscsi_stat_login_attr_indx,
516         &iscsi_stat_login_attr_accepts,
517         &iscsi_stat_login_attr_other_fails,
518         &iscsi_stat_login_attr_redirects,
519         &iscsi_stat_login_attr_authorize_fails,
520         &iscsi_stat_login_attr_authenticate_fails,
521         &iscsi_stat_login_attr_negotiate_fails,
522         NULL,
523 };
524
525 const struct config_item_type iscsi_stat_login_cit = {
526         .ct_attrs               = iscsi_stat_login_stats_attrs,
527         .ct_owner               = THIS_MODULE,
528 };
529
530 /*
531  * Target Logout Stats Table
532  */
533 static struct iscsi_tiqn *iscsi_logout_stat_tiqn(struct config_item *item)
534 {
535         struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
536                         struct iscsi_wwn_stat_grps, iscsi_logout_stats_group);
537         return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
538 }
539
540 static ssize_t iscsi_stat_logout_inst_show(struct config_item *item, char *page)
541 {
542         return snprintf(page, PAGE_SIZE, "%u\n",
543                 iscsi_logout_stat_tiqn(item)->tiqn_index);
544 }
545
546 static ssize_t iscsi_stat_logout_indx_show(struct config_item *item, char *page)
547 {
548         return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
549 }
550
551 static ssize_t iscsi_stat_logout_normal_logouts_show(struct config_item *item,
552                 char *page)
553 {
554         struct iscsi_tiqn *tiqn = iscsi_logout_stat_tiqn(item);
555         struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
556
557         return snprintf(page, PAGE_SIZE, "%u\n", lstats->normal_logouts);
558 }
559
560 static ssize_t iscsi_stat_logout_abnormal_logouts_show(struct config_item *item,
561                 char *page)
562 {
563         struct iscsi_tiqn *tiqn = iscsi_logout_stat_tiqn(item);
564         struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
565
566         return snprintf(page, PAGE_SIZE, "%u\n", lstats->abnormal_logouts);
567 }
568
569 CONFIGFS_ATTR_RO(iscsi_stat_logout_, inst);
570 CONFIGFS_ATTR_RO(iscsi_stat_logout_, indx);
571 CONFIGFS_ATTR_RO(iscsi_stat_logout_, normal_logouts);
572 CONFIGFS_ATTR_RO(iscsi_stat_logout_, abnormal_logouts);
573
574 static struct configfs_attribute *iscsi_stat_logout_stats_attrs[] = {
575         &iscsi_stat_logout_attr_inst,
576         &iscsi_stat_logout_attr_indx,
577         &iscsi_stat_logout_attr_normal_logouts,
578         &iscsi_stat_logout_attr_abnormal_logouts,
579         NULL,
580 };
581
582 const struct config_item_type iscsi_stat_logout_cit = {
583         .ct_attrs               = iscsi_stat_logout_stats_attrs,
584         .ct_owner               = THIS_MODULE,
585 };
586
587 /*
588  * Session Stats Table
589  */
590 static struct iscsi_node_acl *iscsi_stat_nacl(struct config_item *item)
591 {
592         struct iscsi_node_stat_grps *igrps = container_of(to_config_group(item),
593                         struct iscsi_node_stat_grps, iscsi_sess_stats_group);
594         return container_of(igrps, struct iscsi_node_acl, node_stat_grps);
595 }
596
597 static ssize_t iscsi_stat_sess_inst_show(struct config_item *item, char *page)
598 {
599         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
600         struct se_wwn *wwn = acl->se_node_acl.se_tpg->se_tpg_wwn;
601         struct iscsi_tiqn *tiqn = container_of(wwn,
602                         struct iscsi_tiqn, tiqn_wwn);
603
604         return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
605 }
606
607 static ssize_t iscsi_stat_sess_node_show(struct config_item *item, char *page)
608 {
609         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
610         struct se_node_acl *se_nacl = &acl->se_node_acl;
611         struct iscsi_session *sess;
612         struct se_session *se_sess;
613         ssize_t ret = 0;
614
615         spin_lock_bh(&se_nacl->nacl_sess_lock);
616         se_sess = se_nacl->nacl_sess;
617         if (se_sess) {
618                 sess = se_sess->fabric_sess_ptr;
619                 if (sess)
620                         ret = snprintf(page, PAGE_SIZE, "%u\n",
621                                 sess->sess_ops->SessionType ? 0 : ISCSI_NODE_INDEX);
622         }
623         spin_unlock_bh(&se_nacl->nacl_sess_lock);
624
625         return ret;
626 }
627
628 static ssize_t iscsi_stat_sess_indx_show(struct config_item *item, char *page)
629 {
630         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
631         struct se_node_acl *se_nacl = &acl->se_node_acl;
632         struct iscsi_session *sess;
633         struct se_session *se_sess;
634         ssize_t ret = 0;
635
636         spin_lock_bh(&se_nacl->nacl_sess_lock);
637         se_sess = se_nacl->nacl_sess;
638         if (se_sess) {
639                 sess = se_sess->fabric_sess_ptr;
640                 if (sess)
641                         ret = snprintf(page, PAGE_SIZE, "%u\n",
642                                         sess->session_index);
643         }
644         spin_unlock_bh(&se_nacl->nacl_sess_lock);
645
646         return ret;
647 }
648
649 static ssize_t iscsi_stat_sess_cmd_pdus_show(struct config_item *item,
650                 char *page)
651 {
652         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
653         struct se_node_acl *se_nacl = &acl->se_node_acl;
654         struct iscsi_session *sess;
655         struct se_session *se_sess;
656         ssize_t ret = 0;
657
658         spin_lock_bh(&se_nacl->nacl_sess_lock);
659         se_sess = se_nacl->nacl_sess;
660         if (se_sess) {
661                 sess = se_sess->fabric_sess_ptr;
662                 if (sess)
663                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
664                                        atomic_long_read(&sess->cmd_pdus));
665         }
666         spin_unlock_bh(&se_nacl->nacl_sess_lock);
667
668         return ret;
669 }
670
671 static ssize_t iscsi_stat_sess_rsp_pdus_show(struct config_item *item,
672                 char *page)
673 {
674         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
675         struct se_node_acl *se_nacl = &acl->se_node_acl;
676         struct iscsi_session *sess;
677         struct se_session *se_sess;
678         ssize_t ret = 0;
679
680         spin_lock_bh(&se_nacl->nacl_sess_lock);
681         se_sess = se_nacl->nacl_sess;
682         if (se_sess) {
683                 sess = se_sess->fabric_sess_ptr;
684                 if (sess)
685                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
686                                        atomic_long_read(&sess->rsp_pdus));
687         }
688         spin_unlock_bh(&se_nacl->nacl_sess_lock);
689
690         return ret;
691 }
692
693 static ssize_t iscsi_stat_sess_txdata_octs_show(struct config_item *item,
694                 char *page)
695 {
696         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
697         struct se_node_acl *se_nacl = &acl->se_node_acl;
698         struct iscsi_session *sess;
699         struct se_session *se_sess;
700         ssize_t ret = 0;
701
702         spin_lock_bh(&se_nacl->nacl_sess_lock);
703         se_sess = se_nacl->nacl_sess;
704         if (se_sess) {
705                 sess = se_sess->fabric_sess_ptr;
706                 if (sess)
707                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
708                                        atomic_long_read(&sess->tx_data_octets));
709         }
710         spin_unlock_bh(&se_nacl->nacl_sess_lock);
711
712         return ret;
713 }
714
715 static ssize_t iscsi_stat_sess_rxdata_octs_show(struct config_item *item,
716                 char *page)
717 {
718         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
719         struct se_node_acl *se_nacl = &acl->se_node_acl;
720         struct iscsi_session *sess;
721         struct se_session *se_sess;
722         ssize_t ret = 0;
723
724         spin_lock_bh(&se_nacl->nacl_sess_lock);
725         se_sess = se_nacl->nacl_sess;
726         if (se_sess) {
727                 sess = se_sess->fabric_sess_ptr;
728                 if (sess)
729                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
730                                        atomic_long_read(&sess->rx_data_octets));
731         }
732         spin_unlock_bh(&se_nacl->nacl_sess_lock);
733
734         return ret;
735 }
736
737 static ssize_t iscsi_stat_sess_conn_digest_errors_show(struct config_item *item,
738                 char *page)
739 {
740         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
741         struct se_node_acl *se_nacl = &acl->se_node_acl;
742         struct iscsi_session *sess;
743         struct se_session *se_sess;
744         ssize_t ret = 0;
745
746         spin_lock_bh(&se_nacl->nacl_sess_lock);
747         se_sess = se_nacl->nacl_sess;
748         if (se_sess) {
749                 sess = se_sess->fabric_sess_ptr;
750                 if (sess)
751                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
752                                        atomic_long_read(&sess->conn_digest_errors));
753         }
754         spin_unlock_bh(&se_nacl->nacl_sess_lock);
755
756         return ret;
757 }
758
759 static ssize_t iscsi_stat_sess_conn_timeout_errors_show(
760                 struct config_item *item, char *page)
761 {
762         struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
763         struct se_node_acl *se_nacl = &acl->se_node_acl;
764         struct iscsi_session *sess;
765         struct se_session *se_sess;
766         ssize_t ret = 0;
767
768         spin_lock_bh(&se_nacl->nacl_sess_lock);
769         se_sess = se_nacl->nacl_sess;
770         if (se_sess) {
771                 sess = se_sess->fabric_sess_ptr;
772                 if (sess)
773                         ret = snprintf(page, PAGE_SIZE, "%lu\n",
774                                        atomic_long_read(&sess->conn_timeout_errors));
775         }
776         spin_unlock_bh(&se_nacl->nacl_sess_lock);
777
778         return ret;
779 }
780
781 CONFIGFS_ATTR_RO(iscsi_stat_sess_, inst);
782 CONFIGFS_ATTR_RO(iscsi_stat_sess_, node);
783 CONFIGFS_ATTR_RO(iscsi_stat_sess_, indx);
784 CONFIGFS_ATTR_RO(iscsi_stat_sess_, cmd_pdus);
785 CONFIGFS_ATTR_RO(iscsi_stat_sess_, rsp_pdus);
786 CONFIGFS_ATTR_RO(iscsi_stat_sess_, txdata_octs);
787 CONFIGFS_ATTR_RO(iscsi_stat_sess_, rxdata_octs);
788 CONFIGFS_ATTR_RO(iscsi_stat_sess_, conn_digest_errors);
789 CONFIGFS_ATTR_RO(iscsi_stat_sess_, conn_timeout_errors);
790
791 static struct configfs_attribute *iscsi_stat_sess_stats_attrs[] = {
792         &iscsi_stat_sess_attr_inst,
793         &iscsi_stat_sess_attr_node,
794         &iscsi_stat_sess_attr_indx,
795         &iscsi_stat_sess_attr_cmd_pdus,
796         &iscsi_stat_sess_attr_rsp_pdus,
797         &iscsi_stat_sess_attr_txdata_octs,
798         &iscsi_stat_sess_attr_rxdata_octs,
799         &iscsi_stat_sess_attr_conn_digest_errors,
800         &iscsi_stat_sess_attr_conn_timeout_errors,
801         NULL,
802 };
803
804 const struct config_item_type iscsi_stat_sess_cit = {
805         .ct_attrs               = iscsi_stat_sess_stats_attrs,
806         .ct_owner               = THIS_MODULE,
807 };