projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
target: don't truncate the fail intr address
[deliverable/linux.git] / drivers / target / iscsi / iscsi_target_stat.c
CommitLineData
e48354ce
NB		 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>
c53181af 23#include <linux/export.h>
e48354ce
NB		 24#include <scsi/iscsi_proto.h>
25#include <target/target_core_base.h>
e48354ce
NB		 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 */
55CONFIGFS_EATTR_STRUCT(iscsi_stat_instance, iscsi_wwn_stat_grps);
56#define ISCSI_STAT_INSTANCE_ATTR(_name, _mode) \
57static 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) \
64static struct iscsi_stat_instance_attribute \
65 iscsi_stat_instance_##_name = \
66 __CONFIGFS_EATTR_RO(_name, \
67 iscsi_stat_instance_show_attr_##_name);
68
69static 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}
77ISCSI_STAT_INSTANCE_ATTR_RO(inst);
78
79static 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}
84ISCSI_STAT_INSTANCE_ATTR_RO(min_ver);
85
86static 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}
91ISCSI_STAT_INSTANCE_ATTR_RO(max_ver);
92
93static 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}
101ISCSI_STAT_INSTANCE_ATTR_RO(portals);
102
103static 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}
108ISCSI_STAT_INSTANCE_ATTR_RO(nodes);
109
110static 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}
118ISCSI_STAT_INSTANCE_ATTR_RO(sessions);
119
120static 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}
136ISCSI_STAT_INSTANCE_ATTR_RO(fail_sess);
137
138static 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}
148ISCSI_STAT_INSTANCE_ATTR_RO(fail_type);
149
150static 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}
161ISCSI_STAT_INSTANCE_ATTR_RO(fail_rem_name);
162
163static 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}
168ISCSI_STAT_INSTANCE_ATTR_RO(disc_time);
169
170static 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}
175ISCSI_STAT_INSTANCE_ATTR_RO(description);
176
177static 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}
182ISCSI_STAT_INSTANCE_ATTR_RO(vendor);
183
184static 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}
189ISCSI_STAT_INSTANCE_ATTR_RO(version);
190
191CONFIGFS_EATTR_OPS(iscsi_stat_instance, iscsi_wwn_stat_grps,
192 iscsi_instance_group);
193
194static 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
211static 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
216struct 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 */
225CONFIGFS_EATTR_STRUCT(iscsi_stat_sess_err, iscsi_wwn_stat_grps);
226#define ISCSI_STAT_SESS_ERR_ATTR(_name, _mode) \
227static 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) \
234static 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
239static 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}
247ISCSI_STAT_SESS_ERR_ATTR_RO(inst);
248
249static 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}
258ISCSI_STAT_SESS_ERR_ATTR_RO(digest_errors);
259
260static 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}
269ISCSI_STAT_SESS_ERR_ATTR_RO(cxn_errors);
270
271static 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}
280ISCSI_STAT_SESS_ERR_ATTR_RO(format_errors);
281
282CONFIGFS_EATTR_OPS(iscsi_stat_sess_err, iscsi_wwn_stat_grps,
283 iscsi_sess_err_group);
284
285static 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
293static 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
298struct 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 */
307CONFIGFS_EATTR_STRUCT(iscsi_stat_tgt_attr, iscsi_wwn_stat_grps);
308#define ISCSI_STAT_TGT_ATTR(_name, _mode) \
309static 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) \
316static 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
321static 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}
329ISCSI_STAT_TGT_ATTR_RO(inst);
330
331static 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}
336ISCSI_STAT_TGT_ATTR_RO(indx);
337
338static 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}
354ISCSI_STAT_TGT_ATTR_RO(login_fails);
355
356static 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}
372ISCSI_STAT_TGT_ATTR_RO(last_fail_time);
373
374static 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}
388ISCSI_STAT_TGT_ATTR_RO(last_fail_type);
389
390static 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}
405ISCSI_STAT_TGT_ATTR_RO(fail_intr_name);
406
407static 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;
07ea81b6 413 int ret;
e48354ce
NB		 414
415 spin_lock(&lstat->lock);
07ea81b6
DC		 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");
e48354ce
NB		 420 spin_unlock(&lstat->lock);
421
07ea81b6 422 return ret;
e48354ce
NB		 423}
424ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr_type);
425
426static 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;
0e48e7a5 432 int ret;
e48354ce
NB		 433
434 spin_lock(&lstat->lock);
0e48e7a5
DC		 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 }
e48354ce
NB		 442 spin_unlock(&lstat->lock);
443
0e48e7a5 444 return ret;
e48354ce
NB		 445}
446ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr);
447
448CONFIGFS_EATTR_OPS(iscsi_stat_tgt_attr, iscsi_wwn_stat_grps,
449 iscsi_tgt_attr_group);
450
451static 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
463static 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
468struct 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 */
477CONFIGFS_EATTR_STRUCT(iscsi_stat_login, iscsi_wwn_stat_grps);
478#define ISCSI_STAT_LOGIN(_name, _mode) \
479static 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) \
486static struct iscsi_stat_login_attribute \
487 iscsi_stat_login_##_name = \
488 __CONFIGFS_EATTR_RO(_name, \
489 iscsi_stat_login_show_attr_##_name);
490
491static 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}
499ISCSI_STAT_LOGIN_RO(inst);
500
501static 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}
506ISCSI_STAT_LOGIN_RO(indx);
507
508static 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}
522ISCSI_STAT_LOGIN_RO(accepts);
523
524static 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}
538ISCSI_STAT_LOGIN_RO(other_fails);
539
540static 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}
554ISCSI_STAT_LOGIN_RO(redirects);
555
556static 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}
570ISCSI_STAT_LOGIN_RO(authorize_fails);
571
572static 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}
586ISCSI_STAT_LOGIN_RO(authenticate_fails);
587
588static 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}
602ISCSI_STAT_LOGIN_RO(negotiate_fails);
603
604CONFIGFS_EATTR_OPS(iscsi_stat_login, iscsi_wwn_stat_grps,
605 iscsi_login_stats_group);
606
607static 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
619static 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
624struct 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
634CONFIGFS_EATTR_STRUCT(iscsi_stat_logout, iscsi_wwn_stat_grps);
635#define ISCSI_STAT_LOGOUT(_name, _mode) \
636static 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) \
643static struct iscsi_stat_logout_attribute \
644 iscsi_stat_logout_##_name = \
645 __CONFIGFS_EATTR_RO(_name, \
646 iscsi_stat_logout_show_attr_##_name);
647
648static 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}
656ISCSI_STAT_LOGOUT_RO(inst);
657
658static 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}
663ISCSI_STAT_LOGOUT_RO(indx);
664
665static 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}
674ISCSI_STAT_LOGOUT_RO(normal_logouts);
675
676static 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}
685ISCSI_STAT_LOGOUT_RO(abnormal_logouts);
686
687CONFIGFS_EATTR_OPS(iscsi_stat_logout, iscsi_wwn_stat_grps,
688 iscsi_logout_stats_group);
689
690static 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
698static 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
703struct 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
713CONFIGFS_EATTR_STRUCT(iscsi_stat_sess, iscsi_node_stat_grps);
714#define ISCSI_STAT_SESS(_name, _mode) \
715static 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) \
722static struct iscsi_stat_sess_attribute \
723 iscsi_stat_sess_##_name = \
724 __CONFIGFS_EATTR_RO(_name, \
725 iscsi_stat_sess_show_attr_##_name);
726
727static 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}
738ISCSI_STAT_SESS_RO(inst);
739
740static 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) {
8359cf43 753 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
762ISCSI_STAT_SESS_RO(node);
763
764static 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) {
8359cf43 777 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
786ISCSI_STAT_SESS_RO(indx);
787
788static 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) {
8359cf43 801 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
809ISCSI_STAT_SESS_RO(cmd_pdus);
810
811static 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) {
8359cf43 824 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
832ISCSI_STAT_SESS_RO(rsp_pdus);
833
834static 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) {
8359cf43 847 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
856ISCSI_STAT_SESS_RO(txdata_octs);
857
858static 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) {
8359cf43 871 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
880ISCSI_STAT_SESS_RO(rxdata_octs);
881
882static 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) {
8359cf43 895 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
904ISCSI_STAT_SESS_RO(conn_digest_errors);
905
906static 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) {
8359cf43 919 sess = se_sess->fabric_sess_ptr;
e48354ce
NB		 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}
928ISCSI_STAT_SESS_RO(conn_timeout_errors);
929
930CONFIGFS_EATTR_OPS(iscsi_stat_sess, iscsi_node_stat_grps,
931 iscsi_sess_stats_group);
932
933static 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
946static 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
951struct 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};
Linux kernel - Deliverables
This page took 0.144396 seconds and 5 git commands to generate.