1 /*******************************************************************************
2  * Modern ConfigFS group context specific iSCSI statistics based on original
3  * iscsi_target_mib.c code
4  *
5  * Copyright (c) 2011 Rising Tide Systems
6  *
7  * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
8  *
9  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
10  *
11  * This program is free software; you can redistribute it and/or modify
12  * it under the terms of the GNU General Public License as published by
13  * the Free Software Foundation; either version 2 of the License, or
14  * (at your option) any later version.
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  ******************************************************************************/
21 
22 #include <linux/configfs.h>
23 #include <linux/export.h>
24 #include <scsi/iscsi_proto.h>
25 #include <target/target_core_base.h>
26 #include <target/configfs_macros.h>
27 
28 #include "iscsi_target_core.h"
29 #include "iscsi_target_parameters.h"
30 #include "iscsi_target_device.h"
31 #include "iscsi_target_tpg.h"
32 #include "iscsi_target_util.h"
33 #include "iscsi_target_stat.h"
34 
35 #ifndef INITIAL_JIFFIES
36 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
37 #endif
38 
39 /* Instance Attributes Table */
40 #define ISCSI_INST_NUM_NODES		1
41 #define ISCSI_INST_DESCR		"Storage Engine Target"
42 #define ISCSI_INST_LAST_FAILURE_TYPE	0
43 #define ISCSI_DISCONTINUITY_TIME	0
44 
45 #define ISCSI_NODE_INDEX		1
46 
47 #define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
48 
49 /****************************************************************************
50  * iSCSI MIB Tables
51  ****************************************************************************/
52 /*
53  * Instance Attributes Table
54  */
55 CONFIGFS_EATTR_STRUCT(iscsi_stat_instance, iscsi_wwn_stat_grps);
56 #define ISCSI_STAT_INSTANCE_ATTR(_name, _mode)			\
57 static struct iscsi_stat_instance_attribute			\
58 			iscsi_stat_instance_##_name =		\
59 	__CONFIGFS_EATTR(_name, _mode,				\
60 	iscsi_stat_instance_show_attr_##_name,			\
61 	iscsi_stat_instance_store_attr_##_name);
62 
63 #define ISCSI_STAT_INSTANCE_ATTR_RO(_name)			\
64 static struct iscsi_stat_instance_attribute			\
65 			iscsi_stat_instance_##_name =		\
66 	__CONFIGFS_EATTR_RO(_name,				\
67 	iscsi_stat_instance_show_attr_##_name);
68 
69 static ssize_t iscsi_stat_instance_show_attr_inst(
70 	struct iscsi_wwn_stat_grps *igrps, char *page)
71 {
72 	struct iscsi_tiqn *tiqn = container_of(igrps,
73 				struct iscsi_tiqn, tiqn_stat_grps);
74 
75 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
76 }
77 ISCSI_STAT_INSTANCE_ATTR_RO(inst);
78 
79 static ssize_t iscsi_stat_instance_show_attr_min_ver(
80 	struct iscsi_wwn_stat_grps *igrps, char *page)
81 {
82 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
83 }
84 ISCSI_STAT_INSTANCE_ATTR_RO(min_ver);
85 
86 static ssize_t iscsi_stat_instance_show_attr_max_ver(
87 	struct iscsi_wwn_stat_grps *igrps, char *page)
88 {
89 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
90 }
91 ISCSI_STAT_INSTANCE_ATTR_RO(max_ver);
92 
93 static ssize_t iscsi_stat_instance_show_attr_portals(
94 	struct iscsi_wwn_stat_grps *igrps, char *page)
95 {
96 	struct iscsi_tiqn *tiqn = container_of(igrps,
97 				struct iscsi_tiqn, tiqn_stat_grps);
98 
99 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_num_tpg_nps);
100 }
101 ISCSI_STAT_INSTANCE_ATTR_RO(portals);
102 
103 static ssize_t iscsi_stat_instance_show_attr_nodes(
104 	struct iscsi_wwn_stat_grps *igrps, char *page)
105 {
106 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_INST_NUM_NODES);
107 }
108 ISCSI_STAT_INSTANCE_ATTR_RO(nodes);
109 
110 static ssize_t iscsi_stat_instance_show_attr_sessions(
111 	struct iscsi_wwn_stat_grps *igrps, char *page)
112 {
113 	struct iscsi_tiqn *tiqn = container_of(igrps,
114 				struct iscsi_tiqn, tiqn_stat_grps);
115 
116 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_nsessions);
117 }
118 ISCSI_STAT_INSTANCE_ATTR_RO(sessions);
119 
120 static ssize_t iscsi_stat_instance_show_attr_fail_sess(
121 	struct iscsi_wwn_stat_grps *igrps, char *page)
122 {
123 	struct iscsi_tiqn *tiqn = container_of(igrps,
124 				struct iscsi_tiqn, tiqn_stat_grps);
125 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
126 	u32 sess_err_count;
127 
128 	spin_lock_bh(&sess_err->lock);
129 	sess_err_count = (sess_err->digest_errors +
130 			  sess_err->cxn_timeout_errors +
131 			  sess_err->pdu_format_errors);
132 	spin_unlock_bh(&sess_err->lock);
133 
134 	return snprintf(page, PAGE_SIZE, "%u\n", sess_err_count);
135 }
136 ISCSI_STAT_INSTANCE_ATTR_RO(fail_sess);
137 
138 static ssize_t iscsi_stat_instance_show_attr_fail_type(
139 	struct iscsi_wwn_stat_grps *igrps, char *page)
140 {
141 	struct iscsi_tiqn *tiqn = container_of(igrps,
142 				struct iscsi_tiqn, tiqn_stat_grps);
143 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
144 
145 	return snprintf(page, PAGE_SIZE, "%u\n",
146 			sess_err->last_sess_failure_type);
147 }
148 ISCSI_STAT_INSTANCE_ATTR_RO(fail_type);
149 
150 static ssize_t iscsi_stat_instance_show_attr_fail_rem_name(
151 	struct iscsi_wwn_stat_grps *igrps, char *page)
152 {
153 	struct iscsi_tiqn *tiqn = container_of(igrps,
154 				struct iscsi_tiqn, tiqn_stat_grps);
155 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
156 
157 	return snprintf(page, PAGE_SIZE, "%s\n",
158 			sess_err->last_sess_fail_rem_name[0] ?
159 			sess_err->last_sess_fail_rem_name : NONE);
160 }
161 ISCSI_STAT_INSTANCE_ATTR_RO(fail_rem_name);
162 
163 static ssize_t iscsi_stat_instance_show_attr_disc_time(
164 	struct iscsi_wwn_stat_grps *igrps, char *page)
165 {
166 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DISCONTINUITY_TIME);
167 }
168 ISCSI_STAT_INSTANCE_ATTR_RO(disc_time);
169 
170 static ssize_t iscsi_stat_instance_show_attr_description(
171 	struct iscsi_wwn_stat_grps *igrps, char *page)
172 {
173 	return snprintf(page, PAGE_SIZE, "%s\n", ISCSI_INST_DESCR);
174 }
175 ISCSI_STAT_INSTANCE_ATTR_RO(description);
176 
177 static ssize_t iscsi_stat_instance_show_attr_vendor(
178 	struct iscsi_wwn_stat_grps *igrps, char *page)
179 {
180 	return snprintf(page, PAGE_SIZE, "RisingTide Systems iSCSI-Target\n");
181 }
182 ISCSI_STAT_INSTANCE_ATTR_RO(vendor);
183 
184 static ssize_t iscsi_stat_instance_show_attr_version(
185 	struct iscsi_wwn_stat_grps *igrps, char *page)
186 {
187 	return snprintf(page, PAGE_SIZE, "%s\n", ISCSIT_VERSION);
188 }
189 ISCSI_STAT_INSTANCE_ATTR_RO(version);
190 
191 CONFIGFS_EATTR_OPS(iscsi_stat_instance, iscsi_wwn_stat_grps,
192 		iscsi_instance_group);
193 
194 static struct configfs_attribute *iscsi_stat_instance_attrs[] = {
195 	&iscsi_stat_instance_inst.attr,
196 	&iscsi_stat_instance_min_ver.attr,
197 	&iscsi_stat_instance_max_ver.attr,
198 	&iscsi_stat_instance_portals.attr,
199 	&iscsi_stat_instance_nodes.attr,
200 	&iscsi_stat_instance_sessions.attr,
201 	&iscsi_stat_instance_fail_sess.attr,
202 	&iscsi_stat_instance_fail_type.attr,
203 	&iscsi_stat_instance_fail_rem_name.attr,
204 	&iscsi_stat_instance_disc_time.attr,
205 	&iscsi_stat_instance_description.attr,
206 	&iscsi_stat_instance_vendor.attr,
207 	&iscsi_stat_instance_version.attr,
208 	NULL,
209 };
210 
211 static struct configfs_item_operations iscsi_stat_instance_item_ops = {
212 	.show_attribute		= iscsi_stat_instance_attr_show,
213 	.store_attribute	= iscsi_stat_instance_attr_store,
214 };
215 
216 struct config_item_type iscsi_stat_instance_cit = {
217 	.ct_item_ops		= &iscsi_stat_instance_item_ops,
218 	.ct_attrs		= iscsi_stat_instance_attrs,
219 	.ct_owner		= THIS_MODULE,
220 };
221 
222 /*
223  * Instance Session Failure Stats Table
224  */
225 CONFIGFS_EATTR_STRUCT(iscsi_stat_sess_err, iscsi_wwn_stat_grps);
226 #define ISCSI_STAT_SESS_ERR_ATTR(_name, _mode)			\
227 static struct iscsi_stat_sess_err_attribute			\
228 			iscsi_stat_sess_err_##_name =		\
229 	__CONFIGFS_EATTR(_name, _mode,				\
230 	iscsi_stat_sess_err_show_attr_##_name,			\
231 	iscsi_stat_sess_err_store_attr_##_name);
232 
233 #define ISCSI_STAT_SESS_ERR_ATTR_RO(_name)			\
234 static struct iscsi_stat_sess_err_attribute			\
235 			iscsi_stat_sess_err_##_name =		\
236 	__CONFIGFS_EATTR_RO(_name,				\
237 	iscsi_stat_sess_err_show_attr_##_name);
238 
239 static ssize_t iscsi_stat_sess_err_show_attr_inst(
240 	struct iscsi_wwn_stat_grps *igrps, char *page)
241 {
242 	struct iscsi_tiqn *tiqn = container_of(igrps,
243 				struct iscsi_tiqn, tiqn_stat_grps);
244 
245 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
246 }
247 ISCSI_STAT_SESS_ERR_ATTR_RO(inst);
248 
249 static ssize_t iscsi_stat_sess_err_show_attr_digest_errors(
250 	struct iscsi_wwn_stat_grps *igrps, char *page)
251 {
252 	struct iscsi_tiqn *tiqn = container_of(igrps,
253 				struct iscsi_tiqn, tiqn_stat_grps);
254 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
255 
256 	return snprintf(page, PAGE_SIZE, "%u\n", sess_err->digest_errors);
257 }
258 ISCSI_STAT_SESS_ERR_ATTR_RO(digest_errors);
259 
260 static ssize_t iscsi_stat_sess_err_show_attr_cxn_errors(
261 	struct iscsi_wwn_stat_grps *igrps, char *page)
262 {
263 	struct iscsi_tiqn *tiqn = container_of(igrps,
264 				struct iscsi_tiqn, tiqn_stat_grps);
265 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
266 
267 	return snprintf(page, PAGE_SIZE, "%u\n", sess_err->cxn_timeout_errors);
268 }
269 ISCSI_STAT_SESS_ERR_ATTR_RO(cxn_errors);
270 
271 static ssize_t iscsi_stat_sess_err_show_attr_format_errors(
272 	struct iscsi_wwn_stat_grps *igrps, char *page)
273 {
274 	struct iscsi_tiqn *tiqn = container_of(igrps,
275 				struct iscsi_tiqn, tiqn_stat_grps);
276 	struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
277 
278 	return snprintf(page, PAGE_SIZE, "%u\n", sess_err->pdu_format_errors);
279 }
280 ISCSI_STAT_SESS_ERR_ATTR_RO(format_errors);
281 
282 CONFIGFS_EATTR_OPS(iscsi_stat_sess_err, iscsi_wwn_stat_grps,
283 		iscsi_sess_err_group);
284 
285 static struct configfs_attribute *iscsi_stat_sess_err_attrs[] = {
286 	&iscsi_stat_sess_err_inst.attr,
287 	&iscsi_stat_sess_err_digest_errors.attr,
288 	&iscsi_stat_sess_err_cxn_errors.attr,
289 	&iscsi_stat_sess_err_format_errors.attr,
290 	NULL,
291 };
292 
293 static struct configfs_item_operations iscsi_stat_sess_err_item_ops = {
294 	.show_attribute		= iscsi_stat_sess_err_attr_show,
295 	.store_attribute	= iscsi_stat_sess_err_attr_store,
296 };
297 
298 struct config_item_type iscsi_stat_sess_err_cit = {
299 	.ct_item_ops		= &iscsi_stat_sess_err_item_ops,
300 	.ct_attrs		= iscsi_stat_sess_err_attrs,
301 	.ct_owner		= THIS_MODULE,
302 };
303 
304 /*
305  * Target Attributes Table
306  */
307 CONFIGFS_EATTR_STRUCT(iscsi_stat_tgt_attr, iscsi_wwn_stat_grps);
308 #define ISCSI_STAT_TGT_ATTR(_name, _mode)			\
309 static struct iscsi_stat_tgt_attr_attribute			\
310 			iscsi_stat_tgt_attr_##_name =		\
311 	__CONFIGFS_EATTR(_name, _mode,				\
312 	iscsi_stat_tgt-attr_show_attr_##_name,			\
313 	iscsi_stat_tgt_attr_store_attr_##_name);
314 
315 #define ISCSI_STAT_TGT_ATTR_RO(_name)				\
316 static struct iscsi_stat_tgt_attr_attribute			\
317 			iscsi_stat_tgt_attr_##_name =		\
318 	__CONFIGFS_EATTR_RO(_name,				\
319 	iscsi_stat_tgt_attr_show_attr_##_name);
320 
321 static ssize_t iscsi_stat_tgt_attr_show_attr_inst(
322 	struct iscsi_wwn_stat_grps *igrps, char *page)
323 {
324 	struct iscsi_tiqn *tiqn = container_of(igrps,
325 				struct iscsi_tiqn, tiqn_stat_grps);
326 
327 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
328 }
329 ISCSI_STAT_TGT_ATTR_RO(inst);
330 
331 static ssize_t iscsi_stat_tgt_attr_show_attr_indx(
332 	struct iscsi_wwn_stat_grps *igrps, char *page)
333 {
334 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
335 }
336 ISCSI_STAT_TGT_ATTR_RO(indx);
337 
338 static ssize_t iscsi_stat_tgt_attr_show_attr_login_fails(
339 	struct iscsi_wwn_stat_grps *igrps, char *page)
340 {
341 	struct iscsi_tiqn *tiqn = container_of(igrps,
342 				struct iscsi_tiqn, tiqn_stat_grps);
343 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
344 	u32 fail_count;
345 
346 	spin_lock(&lstat->lock);
347 	fail_count = (lstat->redirects + lstat->authorize_fails +
348 			lstat->authenticate_fails + lstat->negotiate_fails +
349 			lstat->other_fails);
350 	spin_unlock(&lstat->lock);
351 
352 	return snprintf(page, PAGE_SIZE, "%u\n", fail_count);
353 }
354 ISCSI_STAT_TGT_ATTR_RO(login_fails);
355 
356 static ssize_t iscsi_stat_tgt_attr_show_attr_last_fail_time(
357 	struct iscsi_wwn_stat_grps *igrps, char *page)
358 {
359 	struct iscsi_tiqn *tiqn = container_of(igrps,
360 				struct iscsi_tiqn, tiqn_stat_grps);
361 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
362 	u32 last_fail_time;
363 
364 	spin_lock(&lstat->lock);
365 	last_fail_time = lstat->last_fail_time ?
366 			(u32)(((u32)lstat->last_fail_time -
367 				INITIAL_JIFFIES) * 100 / HZ) : 0;
368 	spin_unlock(&lstat->lock);
369 
370 	return snprintf(page, PAGE_SIZE, "%u\n", last_fail_time);
371 }
372 ISCSI_STAT_TGT_ATTR_RO(last_fail_time);
373 
374 static ssize_t iscsi_stat_tgt_attr_show_attr_last_fail_type(
375 	struct iscsi_wwn_stat_grps *igrps, char *page)
376 {
377 	struct iscsi_tiqn *tiqn = container_of(igrps,
378 				struct iscsi_tiqn, tiqn_stat_grps);
379 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
380 	u32 last_fail_type;
381 
382 	spin_lock(&lstat->lock);
383 	last_fail_type = lstat->last_fail_type;
384 	spin_unlock(&lstat->lock);
385 
386 	return snprintf(page, PAGE_SIZE, "%u\n", last_fail_type);
387 }
388 ISCSI_STAT_TGT_ATTR_RO(last_fail_type);
389 
390 static ssize_t iscsi_stat_tgt_attr_show_attr_fail_intr_name(
391 	struct iscsi_wwn_stat_grps *igrps, char *page)
392 {
393 	struct iscsi_tiqn *tiqn = container_of(igrps,
394 				struct iscsi_tiqn, tiqn_stat_grps);
395 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
396 	unsigned char buf[224];
397 
398 	spin_lock(&lstat->lock);
399 	snprintf(buf, 224, "%s", lstat->last_intr_fail_name[0] ?
400 				lstat->last_intr_fail_name : NONE);
401 	spin_unlock(&lstat->lock);
402 
403 	return snprintf(page, PAGE_SIZE, "%s\n", buf);
404 }
405 ISCSI_STAT_TGT_ATTR_RO(fail_intr_name);
406 
407 static ssize_t iscsi_stat_tgt_attr_show_attr_fail_intr_addr_type(
408 	struct iscsi_wwn_stat_grps *igrps, char *page)
409 {
410 	struct iscsi_tiqn *tiqn = container_of(igrps,
411 			struct iscsi_tiqn, tiqn_stat_grps);
412 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
413 	int ret;
414 
415 	spin_lock(&lstat->lock);
416 	if (lstat->last_intr_fail_ip_family == AF_INET6)
417 		ret = snprintf(page, PAGE_SIZE, "ipv6\n");
418 	else
419 		ret = snprintf(page, PAGE_SIZE, "ipv4\n");
420 	spin_unlock(&lstat->lock);
421 
422 	return ret;
423 }
424 ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr_type);
425 
426 static ssize_t iscsi_stat_tgt_attr_show_attr_fail_intr_addr(
427 	struct iscsi_wwn_stat_grps *igrps, char *page)
428 {
429 	struct iscsi_tiqn *tiqn = container_of(igrps,
430 			struct iscsi_tiqn, tiqn_stat_grps);
431 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
432 	int ret;
433 
434 	spin_lock(&lstat->lock);
435 	if (lstat->last_intr_fail_ip_family == AF_INET6) {
436 		ret = snprintf(page, PAGE_SIZE, "[%s]\n",
437 			       lstat->last_intr_fail_ip_addr);
438 	} else {
439 		ret = snprintf(page, PAGE_SIZE, "%s\n",
440 			       lstat->last_intr_fail_ip_addr);
441 	}
442 	spin_unlock(&lstat->lock);
443 
444 	return ret;
445 }
446 ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr);
447 
448 CONFIGFS_EATTR_OPS(iscsi_stat_tgt_attr, iscsi_wwn_stat_grps,
449 		iscsi_tgt_attr_group);
450 
451 static struct configfs_attribute *iscsi_stat_tgt_attr_attrs[] = {
452 	&iscsi_stat_tgt_attr_inst.attr,
453 	&iscsi_stat_tgt_attr_indx.attr,
454 	&iscsi_stat_tgt_attr_login_fails.attr,
455 	&iscsi_stat_tgt_attr_last_fail_time.attr,
456 	&iscsi_stat_tgt_attr_last_fail_type.attr,
457 	&iscsi_stat_tgt_attr_fail_intr_name.attr,
458 	&iscsi_stat_tgt_attr_fail_intr_addr_type.attr,
459 	&iscsi_stat_tgt_attr_fail_intr_addr.attr,
460 	NULL,
461 };
462 
463 static struct configfs_item_operations iscsi_stat_tgt_attr_item_ops = {
464 	.show_attribute		= iscsi_stat_tgt_attr_attr_show,
465 	.store_attribute	= iscsi_stat_tgt_attr_attr_store,
466 };
467 
468 struct config_item_type iscsi_stat_tgt_attr_cit = {
469 	.ct_item_ops		= &iscsi_stat_tgt_attr_item_ops,
470 	.ct_attrs		= iscsi_stat_tgt_attr_attrs,
471 	.ct_owner		= THIS_MODULE,
472 };
473 
474 /*
475  * Target Login Stats Table
476  */
477 CONFIGFS_EATTR_STRUCT(iscsi_stat_login, iscsi_wwn_stat_grps);
478 #define ISCSI_STAT_LOGIN(_name, _mode)				\
479 static struct iscsi_stat_login_attribute			\
480 			iscsi_stat_login_##_name =		\
481 	__CONFIGFS_EATTR(_name, _mode,				\
482 	iscsi_stat_login_show_attr_##_name,			\
483 	iscsi_stat_login_store_attr_##_name);
484 
485 #define ISCSI_STAT_LOGIN_RO(_name)				\
486 static struct iscsi_stat_login_attribute			\
487 			iscsi_stat_login_##_name =		\
488 	__CONFIGFS_EATTR_RO(_name,				\
489 	iscsi_stat_login_show_attr_##_name);
490 
491 static ssize_t iscsi_stat_login_show_attr_inst(
492 	struct iscsi_wwn_stat_grps *igrps, char *page)
493 {
494 	struct iscsi_tiqn *tiqn = container_of(igrps,
495 				struct iscsi_tiqn, tiqn_stat_grps);
496 
497 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
498 }
499 ISCSI_STAT_LOGIN_RO(inst);
500 
501 static ssize_t iscsi_stat_login_show_attr_indx(
502 	struct iscsi_wwn_stat_grps *igrps, char *page)
503 {
504 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
505 }
506 ISCSI_STAT_LOGIN_RO(indx);
507 
508 static ssize_t iscsi_stat_login_show_attr_accepts(
509 	struct iscsi_wwn_stat_grps *igrps, char *page)
510 {
511 	struct iscsi_tiqn *tiqn = container_of(igrps,
512 				struct iscsi_tiqn, tiqn_stat_grps);
513 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
514 	ssize_t ret;
515 
516 	spin_lock(&lstat->lock);
517 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->accepts);
518 	spin_unlock(&lstat->lock);
519 
520 	return ret;
521 }
522 ISCSI_STAT_LOGIN_RO(accepts);
523 
524 static ssize_t iscsi_stat_login_show_attr_other_fails(
525 	struct iscsi_wwn_stat_grps *igrps, char *page)
526 {
527 	struct iscsi_tiqn *tiqn = container_of(igrps,
528 				struct iscsi_tiqn, tiqn_stat_grps);
529 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
530 	ssize_t ret;
531 
532 	spin_lock(&lstat->lock);
533 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->other_fails);
534 	spin_unlock(&lstat->lock);
535 
536 	return ret;
537 }
538 ISCSI_STAT_LOGIN_RO(other_fails);
539 
540 static ssize_t iscsi_stat_login_show_attr_redirects(
541 	struct iscsi_wwn_stat_grps *igrps, char *page)
542 {
543 	struct iscsi_tiqn *tiqn = container_of(igrps,
544 				struct iscsi_tiqn, tiqn_stat_grps);
545 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
546 	ssize_t ret;
547 
548 	spin_lock(&lstat->lock);
549 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->redirects);
550 	spin_unlock(&lstat->lock);
551 
552 	return ret;
553 }
554 ISCSI_STAT_LOGIN_RO(redirects);
555 
556 static ssize_t iscsi_stat_login_show_attr_authorize_fails(
557 	struct iscsi_wwn_stat_grps *igrps, char *page)
558 {
559 	struct iscsi_tiqn *tiqn = container_of(igrps,
560 				struct iscsi_tiqn, tiqn_stat_grps);
561 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
562 	ssize_t ret;
563 
564 	spin_lock(&lstat->lock);
565 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authorize_fails);
566 	spin_unlock(&lstat->lock);
567 
568 	return ret;
569 }
570 ISCSI_STAT_LOGIN_RO(authorize_fails);
571 
572 static ssize_t iscsi_stat_login_show_attr_authenticate_fails(
573 	struct iscsi_wwn_stat_grps *igrps, char *page)
574 {
575 	struct iscsi_tiqn *tiqn = container_of(igrps,
576 				struct iscsi_tiqn, tiqn_stat_grps);
577 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
578 	ssize_t ret;
579 
580 	spin_lock(&lstat->lock);
581 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authenticate_fails);
582 	spin_unlock(&lstat->lock);
583 
584 	return ret;
585 }
586 ISCSI_STAT_LOGIN_RO(authenticate_fails);
587 
588 static ssize_t iscsi_stat_login_show_attr_negotiate_fails(
589 	struct iscsi_wwn_stat_grps *igrps, char *page)
590 {
591 	struct iscsi_tiqn *tiqn = container_of(igrps,
592 				struct iscsi_tiqn, tiqn_stat_grps);
593 	struct iscsi_login_stats *lstat = &tiqn->login_stats;
594 	ssize_t ret;
595 
596 	spin_lock(&lstat->lock);
597 	ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->negotiate_fails);
598 	spin_unlock(&lstat->lock);
599 
600 	return ret;
601 }
602 ISCSI_STAT_LOGIN_RO(negotiate_fails);
603 
604 CONFIGFS_EATTR_OPS(iscsi_stat_login, iscsi_wwn_stat_grps,
605 		iscsi_login_stats_group);
606 
607 static struct configfs_attribute *iscsi_stat_login_stats_attrs[] = {
608 	&iscsi_stat_login_inst.attr,
609 	&iscsi_stat_login_indx.attr,
610 	&iscsi_stat_login_accepts.attr,
611 	&iscsi_stat_login_other_fails.attr,
612 	&iscsi_stat_login_redirects.attr,
613 	&iscsi_stat_login_authorize_fails.attr,
614 	&iscsi_stat_login_authenticate_fails.attr,
615 	&iscsi_stat_login_negotiate_fails.attr,
616 	NULL,
617 };
618 
619 static struct configfs_item_operations iscsi_stat_login_stats_item_ops = {
620 	.show_attribute		= iscsi_stat_login_attr_show,
621 	.store_attribute	= iscsi_stat_login_attr_store,
622 };
623 
624 struct config_item_type iscsi_stat_login_cit = {
625 	.ct_item_ops		= &iscsi_stat_login_stats_item_ops,
626 	.ct_attrs		= iscsi_stat_login_stats_attrs,
627 	.ct_owner		= THIS_MODULE,
628 };
629 
630 /*
631  * Target Logout Stats Table
632  */
633 
634 CONFIGFS_EATTR_STRUCT(iscsi_stat_logout, iscsi_wwn_stat_grps);
635 #define ISCSI_STAT_LOGOUT(_name, _mode)				\
636 static struct iscsi_stat_logout_attribute			\
637 			iscsi_stat_logout_##_name =		\
638 	__CONFIGFS_EATTR(_name, _mode,				\
639 	iscsi_stat_logout_show_attr_##_name,			\
640 	iscsi_stat_logout_store_attr_##_name);
641 
642 #define ISCSI_STAT_LOGOUT_RO(_name)				\
643 static struct iscsi_stat_logout_attribute			\
644 			iscsi_stat_logout_##_name =		\
645 	__CONFIGFS_EATTR_RO(_name,				\
646 	iscsi_stat_logout_show_attr_##_name);
647 
648 static ssize_t iscsi_stat_logout_show_attr_inst(
649 	struct iscsi_wwn_stat_grps *igrps, char *page)
650 {
651 	struct iscsi_tiqn *tiqn = container_of(igrps,
652 			struct iscsi_tiqn, tiqn_stat_grps);
653 
654 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
655 }
656 ISCSI_STAT_LOGOUT_RO(inst);
657 
658 static ssize_t iscsi_stat_logout_show_attr_indx(
659 	struct iscsi_wwn_stat_grps *igrps, char *page)
660 {
661 	return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
662 }
663 ISCSI_STAT_LOGOUT_RO(indx);
664 
665 static ssize_t iscsi_stat_logout_show_attr_normal_logouts(
666 	struct iscsi_wwn_stat_grps *igrps, char *page)
667 {
668 	struct iscsi_tiqn *tiqn = container_of(igrps,
669 			struct iscsi_tiqn, tiqn_stat_grps);
670 	struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
671 
672 	return snprintf(page, PAGE_SIZE, "%u\n", lstats->normal_logouts);
673 }
674 ISCSI_STAT_LOGOUT_RO(normal_logouts);
675 
676 static ssize_t iscsi_stat_logout_show_attr_abnormal_logouts(
677 	struct iscsi_wwn_stat_grps *igrps, char *page)
678 {
679 	struct iscsi_tiqn *tiqn = container_of(igrps,
680 			struct iscsi_tiqn, tiqn_stat_grps);
681 	struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
682 
683 	return snprintf(page, PAGE_SIZE, "%u\n", lstats->abnormal_logouts);
684 }
685 ISCSI_STAT_LOGOUT_RO(abnormal_logouts);
686 
687 CONFIGFS_EATTR_OPS(iscsi_stat_logout, iscsi_wwn_stat_grps,
688 		iscsi_logout_stats_group);
689 
690 static struct configfs_attribute *iscsi_stat_logout_stats_attrs[] = {
691 	&iscsi_stat_logout_inst.attr,
692 	&iscsi_stat_logout_indx.attr,
693 	&iscsi_stat_logout_normal_logouts.attr,
694 	&iscsi_stat_logout_abnormal_logouts.attr,
695 	NULL,
696 };
697 
698 static struct configfs_item_operations iscsi_stat_logout_stats_item_ops = {
699 	.show_attribute		= iscsi_stat_logout_attr_show,
700 	.store_attribute	= iscsi_stat_logout_attr_store,
701 };
702 
703 struct config_item_type iscsi_stat_logout_cit = {
704 	.ct_item_ops		= &iscsi_stat_logout_stats_item_ops,
705 	.ct_attrs		= iscsi_stat_logout_stats_attrs,
706 	.ct_owner		= THIS_MODULE,
707 };
708 
709 /*
710  * Session Stats Table
711  */
712 
713 CONFIGFS_EATTR_STRUCT(iscsi_stat_sess, iscsi_node_stat_grps);
714 #define ISCSI_STAT_SESS(_name, _mode)				\
715 static struct iscsi_stat_sess_attribute				\
716 			iscsi_stat_sess_##_name =		\
717 	__CONFIGFS_EATTR(_name, _mode,				\
718 	iscsi_stat_sess_show_attr_##_name,			\
719 	iscsi_stat_sess_store_attr_##_name);
720 
721 #define ISCSI_STAT_SESS_RO(_name)				\
722 static struct iscsi_stat_sess_attribute				\
723 			iscsi_stat_sess_##_name =		\
724 	__CONFIGFS_EATTR_RO(_name,				\
725 	iscsi_stat_sess_show_attr_##_name);
726 
727 static ssize_t iscsi_stat_sess_show_attr_inst(
728 	struct iscsi_node_stat_grps *igrps, char *page)
729 {
730 	struct iscsi_node_acl *acl = container_of(igrps,
731 			struct iscsi_node_acl, node_stat_grps);
732 	struct se_wwn *wwn = acl->se_node_acl.se_tpg->se_tpg_wwn;
733 	struct iscsi_tiqn *tiqn = container_of(wwn,
734 			struct iscsi_tiqn, tiqn_wwn);
735 
736 	return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
737 }
738 ISCSI_STAT_SESS_RO(inst);
739 
740 static ssize_t iscsi_stat_sess_show_attr_node(
741 	struct iscsi_node_stat_grps *igrps, char *page)
742 {
743 	struct iscsi_node_acl *acl = container_of(igrps,
744 			struct iscsi_node_acl, node_stat_grps);
745 	struct se_node_acl *se_nacl = &acl->se_node_acl;
746 	struct iscsi_session *sess;
747 	struct se_session *se_sess;
748 	ssize_t ret = 0;
749 
750 	spin_lock_bh(&se_nacl->nacl_sess_lock);
751 	se_sess = se_nacl->nacl_sess;
752 	if (se_sess) {
753 		sess = se_sess->fabric_sess_ptr;
754 		if (sess)
755 			ret = snprintf(page, PAGE_SIZE, "%u\n",
756 				sess->sess_ops->SessionType ? 0 : ISCSI_NODE_INDEX);
757 	}
758 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
759 
760 	return ret;
761 }
762 ISCSI_STAT_SESS_RO(node);
763 
764 static ssize_t iscsi_stat_sess_show_attr_indx(
765 	struct iscsi_node_stat_grps *igrps, char *page)
766 {
767 	struct iscsi_node_acl *acl = container_of(igrps,
768 			struct iscsi_node_acl, node_stat_grps);
769 	struct se_node_acl *se_nacl = &acl->se_node_acl;
770 	struct iscsi_session *sess;
771 	struct se_session *se_sess;
772 	ssize_t ret = 0;
773 
774 	spin_lock_bh(&se_nacl->nacl_sess_lock);
775 	se_sess = se_nacl->nacl_sess;
776 	if (se_sess) {
777 		sess = se_sess->fabric_sess_ptr;
778 		if (sess)
779 			ret = snprintf(page, PAGE_SIZE, "%u\n",
780 					sess->session_index);
781 	}
782 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
783 
784 	return ret;
785 }
786 ISCSI_STAT_SESS_RO(indx);
787 
788 static ssize_t iscsi_stat_sess_show_attr_cmd_pdus(
789 	struct iscsi_node_stat_grps *igrps, char *page)
790 {
791 	struct iscsi_node_acl *acl = container_of(igrps,
792 			struct iscsi_node_acl, node_stat_grps);
793 	struct se_node_acl *se_nacl = &acl->se_node_acl;
794 	struct iscsi_session *sess;
795 	struct se_session *se_sess;
796 	ssize_t ret = 0;
797 
798 	spin_lock_bh(&se_nacl->nacl_sess_lock);
799 	se_sess = se_nacl->nacl_sess;
800 	if (se_sess) {
801 		sess = se_sess->fabric_sess_ptr;
802 		if (sess)
803 			ret = snprintf(page, PAGE_SIZE, "%u\n", sess->cmd_pdus);
804 	}
805 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
806 
807 	return ret;
808 }
809 ISCSI_STAT_SESS_RO(cmd_pdus);
810 
811 static ssize_t iscsi_stat_sess_show_attr_rsp_pdus(
812 	struct iscsi_node_stat_grps *igrps, char *page)
813 {
814 	struct iscsi_node_acl *acl = container_of(igrps,
815 			struct iscsi_node_acl, node_stat_grps);
816 	struct se_node_acl *se_nacl = &acl->se_node_acl;
817 	struct iscsi_session *sess;
818 	struct se_session *se_sess;
819 	ssize_t ret = 0;
820 
821 	spin_lock_bh(&se_nacl->nacl_sess_lock);
822 	se_sess = se_nacl->nacl_sess;
823 	if (se_sess) {
824 		sess = se_sess->fabric_sess_ptr;
825 		if (sess)
826 			ret = snprintf(page, PAGE_SIZE, "%u\n", sess->rsp_pdus);
827 	}
828 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
829 
830 	return ret;
831 }
832 ISCSI_STAT_SESS_RO(rsp_pdus);
833 
834 static ssize_t iscsi_stat_sess_show_attr_txdata_octs(
835 	struct iscsi_node_stat_grps *igrps, char *page)
836 {
837 	struct iscsi_node_acl *acl = container_of(igrps,
838 			struct iscsi_node_acl, node_stat_grps);
839 	struct se_node_acl *se_nacl = &acl->se_node_acl;
840 	struct iscsi_session *sess;
841 	struct se_session *se_sess;
842 	ssize_t ret = 0;
843 
844 	spin_lock_bh(&se_nacl->nacl_sess_lock);
845 	se_sess = se_nacl->nacl_sess;
846 	if (se_sess) {
847 		sess = se_sess->fabric_sess_ptr;
848 		if (sess)
849 			ret = snprintf(page, PAGE_SIZE, "%llu\n",
850 				(unsigned long long)sess->tx_data_octets);
851 	}
852 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
853 
854 	return ret;
855 }
856 ISCSI_STAT_SESS_RO(txdata_octs);
857 
858 static ssize_t iscsi_stat_sess_show_attr_rxdata_octs(
859 	struct iscsi_node_stat_grps *igrps, char *page)
860 {
861 	struct iscsi_node_acl *acl = container_of(igrps,
862 			struct iscsi_node_acl, node_stat_grps);
863 	struct se_node_acl *se_nacl = &acl->se_node_acl;
864 	struct iscsi_session *sess;
865 	struct se_session *se_sess;
866 	ssize_t ret = 0;
867 
868 	spin_lock_bh(&se_nacl->nacl_sess_lock);
869 	se_sess = se_nacl->nacl_sess;
870 	if (se_sess) {
871 		sess = se_sess->fabric_sess_ptr;
872 		if (sess)
873 			ret = snprintf(page, PAGE_SIZE, "%llu\n",
874 				(unsigned long long)sess->rx_data_octets);
875 	}
876 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
877 
878 	return ret;
879 }
880 ISCSI_STAT_SESS_RO(rxdata_octs);
881 
882 static ssize_t iscsi_stat_sess_show_attr_conn_digest_errors(
883 	struct iscsi_node_stat_grps *igrps, char *page)
884 {
885 	struct iscsi_node_acl *acl = container_of(igrps,
886 			struct iscsi_node_acl, node_stat_grps);
887 	struct se_node_acl *se_nacl = &acl->se_node_acl;
888 	struct iscsi_session *sess;
889 	struct se_session *se_sess;
890 	ssize_t ret = 0;
891 
892 	spin_lock_bh(&se_nacl->nacl_sess_lock);
893 	se_sess = se_nacl->nacl_sess;
894 	if (se_sess) {
895 		sess = se_sess->fabric_sess_ptr;
896 		if (sess)
897 			ret = snprintf(page, PAGE_SIZE, "%u\n",
898 					sess->conn_digest_errors);
899 	}
900 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
901 
902 	return ret;
903 }
904 ISCSI_STAT_SESS_RO(conn_digest_errors);
905 
906 static ssize_t iscsi_stat_sess_show_attr_conn_timeout_errors(
907 	struct iscsi_node_stat_grps *igrps, char *page)
908 {
909 	struct iscsi_node_acl *acl = container_of(igrps,
910 			struct iscsi_node_acl, node_stat_grps);
911 	struct se_node_acl *se_nacl = &acl->se_node_acl;
912 	struct iscsi_session *sess;
913 	struct se_session *se_sess;
914 	ssize_t ret = 0;
915 
916 	spin_lock_bh(&se_nacl->nacl_sess_lock);
917 	se_sess = se_nacl->nacl_sess;
918 	if (se_sess) {
919 		sess = se_sess->fabric_sess_ptr;
920 		if (sess)
921 			ret = snprintf(page, PAGE_SIZE, "%u\n",
922 					sess->conn_timeout_errors);
923 	}
924 	spin_unlock_bh(&se_nacl->nacl_sess_lock);
925 
926 	return ret;
927 }
928 ISCSI_STAT_SESS_RO(conn_timeout_errors);
929 
930 CONFIGFS_EATTR_OPS(iscsi_stat_sess, iscsi_node_stat_grps,
931 		iscsi_sess_stats_group);
932 
933 static struct configfs_attribute *iscsi_stat_sess_stats_attrs[] = {
934 	&iscsi_stat_sess_inst.attr,
935 	&iscsi_stat_sess_node.attr,
936 	&iscsi_stat_sess_indx.attr,
937 	&iscsi_stat_sess_cmd_pdus.attr,
938 	&iscsi_stat_sess_rsp_pdus.attr,
939 	&iscsi_stat_sess_txdata_octs.attr,
940 	&iscsi_stat_sess_rxdata_octs.attr,
941 	&iscsi_stat_sess_conn_digest_errors.attr,
942 	&iscsi_stat_sess_conn_timeout_errors.attr,
943 	NULL,
944 };
945 
946 static struct configfs_item_operations iscsi_stat_sess_stats_item_ops = {
947 	.show_attribute		= iscsi_stat_sess_attr_show,
948 	.store_attribute	= iscsi_stat_sess_attr_store,
949 };
950 
951 struct config_item_type iscsi_stat_sess_cit = {
952 	.ct_item_ops		= &iscsi_stat_sess_stats_item_ops,
953 	.ct_attrs		= iscsi_stat_sess_stats_attrs,
954 	.ct_owner		= THIS_MODULE,
955 };
956