target/iscsi/iscsi_target_stat.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*******************************************************************************
0003  * Modern ConfigFS group context specific iSCSI statistics based on original
0004  * iscsi_target_mib.c code
0005  *
0006  * Copyright (c) 2011-2013 Datera, Inc.
0007  *
0008  * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
0009  *
0010  ******************************************************************************/
0011
0012 #include <linux/configfs.h>
0013 #include <linux/export.h>
0014 #include <scsi/iscsi_proto.h>
0015 #include <target/target_core_base.h>
0016
0017 #include <target/iscsi/iscsi_target_core.h>
0018 #include "iscsi_target_parameters.h"
0019 #include "iscsi_target_device.h"
0020 #include "iscsi_target_tpg.h"
0021 #include "iscsi_target_util.h"
0022 #include <target/iscsi/iscsi_target_stat.h>
0023
0024 #ifndef INITIAL_JIFFIES
0025 #define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
0026 #endif
0027
0028 /* Instance Attributes Table */
0029 #define ISCSI_INST_NUM_NODES        1
0030 #define ISCSI_INST_DESCR        "Storage Engine Target"
0031 #define ISCSI_DISCONTINUITY_TIME    0
0032
0033 #define ISCSI_NODE_INDEX        1
0034
0035 #define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
0036
0037 /****************************************************************************
0038  * iSCSI MIB Tables
0039  ****************************************************************************/
0040 /*
0041  * Instance Attributes Table
0042  */
0043 static struct iscsi_tiqn *iscsi_instance_tiqn(struct config_item *item)
0044 {
0045     struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
0046             struct iscsi_wwn_stat_grps, iscsi_instance_group);
0047     return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
0048 }
0049
0050 static ssize_t iscsi_stat_instance_inst_show(struct config_item *item,
0051         char *page)
0052 {
0053     return snprintf(page, PAGE_SIZE, "%u\n",
0054             iscsi_instance_tiqn(item)->tiqn_index);
0055 }
0056
0057 static ssize_t iscsi_stat_instance_min_ver_show(struct config_item *item,
0058         char *page)
0059 {
0060     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
0061 }
0062
0063 static ssize_t iscsi_stat_instance_max_ver_show(struct config_item *item,
0064         char *page)
0065 {
0066     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DRAFT20_VERSION);
0067 }
0068
0069 static ssize_t iscsi_stat_instance_portals_show(struct config_item *item,
0070         char *page)
0071 {
0072     return snprintf(page, PAGE_SIZE, "%u\n",
0073             iscsi_instance_tiqn(item)->tiqn_num_tpg_nps);
0074 }
0075
0076 static ssize_t iscsi_stat_instance_nodes_show(struct config_item *item,
0077         char *page)
0078 {
0079     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_INST_NUM_NODES);
0080 }
0081
0082 static ssize_t iscsi_stat_instance_sessions_show(struct config_item *item,
0083         char *page)
0084 {
0085     return snprintf(page, PAGE_SIZE, "%u\n",
0086         iscsi_instance_tiqn(item)->tiqn_nsessions);
0087 }
0088
0089 static ssize_t iscsi_stat_instance_fail_sess_show(struct config_item *item,
0090         char *page)
0091 {
0092     struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
0093     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0094     u32 sess_err_count;
0095
0096     spin_lock_bh(&sess_err->lock);
0097     sess_err_count = (sess_err->digest_errors +
0098               sess_err->cxn_timeout_errors +
0099               sess_err->pdu_format_errors);
0100     spin_unlock_bh(&sess_err->lock);
0101
0102     return snprintf(page, PAGE_SIZE, "%u\n", sess_err_count);
0103 }
0104
0105 static ssize_t iscsi_stat_instance_fail_type_show(struct config_item *item,
0106         char *page)
0107 {
0108     struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
0109     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0110
0111     return snprintf(page, PAGE_SIZE, "%u\n",
0112             sess_err->last_sess_failure_type);
0113 }
0114
0115 static ssize_t iscsi_stat_instance_fail_rem_name_show(struct config_item *item,
0116         char *page)
0117 {
0118     struct iscsi_tiqn *tiqn = iscsi_instance_tiqn(item);
0119     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0120
0121     return snprintf(page, PAGE_SIZE, "%s\n",
0122             sess_err->last_sess_fail_rem_name[0] ?
0123             sess_err->last_sess_fail_rem_name : NONE);
0124 }
0125
0126 static ssize_t iscsi_stat_instance_disc_time_show(struct config_item *item,
0127         char *page)
0128 {
0129     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_DISCONTINUITY_TIME);
0130 }
0131
0132 static ssize_t iscsi_stat_instance_description_show(struct config_item *item,
0133         char *page)
0134 {
0135     return snprintf(page, PAGE_SIZE, "%s\n", ISCSI_INST_DESCR);
0136 }
0137
0138 static ssize_t iscsi_stat_instance_vendor_show(struct config_item *item,
0139         char *page)
0140 {
0141     return snprintf(page, PAGE_SIZE, "Datera, Inc. iSCSI-Target\n");
0142 }
0143
0144 static ssize_t iscsi_stat_instance_version_show(struct config_item *item,
0145         char *page)
0146 {
0147     return snprintf(page, PAGE_SIZE, "%s\n", ISCSIT_VERSION);
0148 }
0149
0150 CONFIGFS_ATTR_RO(iscsi_stat_instance_, inst);
0151 CONFIGFS_ATTR_RO(iscsi_stat_instance_, min_ver);
0152 CONFIGFS_ATTR_RO(iscsi_stat_instance_, max_ver);
0153 CONFIGFS_ATTR_RO(iscsi_stat_instance_, portals);
0154 CONFIGFS_ATTR_RO(iscsi_stat_instance_, nodes);
0155 CONFIGFS_ATTR_RO(iscsi_stat_instance_, sessions);
0156 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_sess);
0157 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_type);
0158 CONFIGFS_ATTR_RO(iscsi_stat_instance_, fail_rem_name);
0159 CONFIGFS_ATTR_RO(iscsi_stat_instance_, disc_time);
0160 CONFIGFS_ATTR_RO(iscsi_stat_instance_, description);
0161 CONFIGFS_ATTR_RO(iscsi_stat_instance_, vendor);
0162 CONFIGFS_ATTR_RO(iscsi_stat_instance_, version);
0163
0164 static struct configfs_attribute *iscsi_stat_instance_attrs[] = {
0165     &iscsi_stat_instance_attr_inst,
0166     &iscsi_stat_instance_attr_min_ver,
0167     &iscsi_stat_instance_attr_max_ver,
0168     &iscsi_stat_instance_attr_portals,
0169     &iscsi_stat_instance_attr_nodes,
0170     &iscsi_stat_instance_attr_sessions,
0171     &iscsi_stat_instance_attr_fail_sess,
0172     &iscsi_stat_instance_attr_fail_type,
0173     &iscsi_stat_instance_attr_fail_rem_name,
0174     &iscsi_stat_instance_attr_disc_time,
0175     &iscsi_stat_instance_attr_description,
0176     &iscsi_stat_instance_attr_vendor,
0177     &iscsi_stat_instance_attr_version,
0178     NULL,
0179 };
0180
0181 const struct config_item_type iscsi_stat_instance_cit = {
0182     .ct_attrs       = iscsi_stat_instance_attrs,
0183     .ct_owner       = THIS_MODULE,
0184 };
0185
0186 /*
0187  * Instance Session Failure Stats Table
0188  */
0189 static struct iscsi_tiqn *iscsi_sess_err_tiqn(struct config_item *item)
0190 {
0191     struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
0192             struct iscsi_wwn_stat_grps, iscsi_sess_err_group);
0193     return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
0194 }
0195
0196 static ssize_t iscsi_stat_sess_err_inst_show(struct config_item *item,
0197         char *page)
0198 {
0199     return snprintf(page, PAGE_SIZE, "%u\n",
0200         iscsi_sess_err_tiqn(item)->tiqn_index);
0201 }
0202
0203 static ssize_t iscsi_stat_sess_err_digest_errors_show(struct config_item *item,
0204         char *page)
0205 {
0206     struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
0207     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0208
0209     return snprintf(page, PAGE_SIZE, "%u\n", sess_err->digest_errors);
0210 }
0211
0212 static ssize_t iscsi_stat_sess_err_cxn_errors_show(struct config_item *item,
0213         char *page)
0214 {
0215     struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
0216     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0217
0218     return snprintf(page, PAGE_SIZE, "%u\n", sess_err->cxn_timeout_errors);
0219 }
0220
0221 static ssize_t iscsi_stat_sess_err_format_errors_show(struct config_item *item,
0222         char *page)
0223 {
0224     struct iscsi_tiqn *tiqn = iscsi_sess_err_tiqn(item);
0225     struct iscsi_sess_err_stats *sess_err = &tiqn->sess_err_stats;
0226
0227     return snprintf(page, PAGE_SIZE, "%u\n", sess_err->pdu_format_errors);
0228 }
0229
0230 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, inst);
0231 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, digest_errors);
0232 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, cxn_errors);
0233 CONFIGFS_ATTR_RO(iscsi_stat_sess_err_, format_errors);
0234
0235 static struct configfs_attribute *iscsi_stat_sess_err_attrs[] = {
0236     &iscsi_stat_sess_err_attr_inst,
0237     &iscsi_stat_sess_err_attr_digest_errors,
0238     &iscsi_stat_sess_err_attr_cxn_errors,
0239     &iscsi_stat_sess_err_attr_format_errors,
0240     NULL,
0241 };
0242
0243 const struct config_item_type iscsi_stat_sess_err_cit = {
0244     .ct_attrs       = iscsi_stat_sess_err_attrs,
0245     .ct_owner       = THIS_MODULE,
0246 };
0247
0248 /*
0249  * Target Attributes Table
0250  */
0251 static struct iscsi_tiqn *iscsi_tgt_attr_tiqn(struct config_item *item)
0252 {
0253     struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
0254             struct iscsi_wwn_stat_grps, iscsi_tgt_attr_group);
0255     return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
0256 }
0257
0258 static ssize_t iscsi_stat_tgt_attr_inst_show(struct config_item *item,
0259         char *page)
0260 {
0261     return snprintf(page, PAGE_SIZE, "%u\n",
0262             iscsi_tgt_attr_tiqn(item)->tiqn_index);
0263 }
0264
0265 static ssize_t iscsi_stat_tgt_attr_indx_show(struct config_item *item,
0266         char *page)
0267 {
0268     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
0269 }
0270
0271 static ssize_t iscsi_stat_tgt_attr_login_fails_show(struct config_item *item,
0272         char *page)
0273 {
0274     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0275     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0276     u32 fail_count;
0277
0278     spin_lock(&lstat->lock);
0279     fail_count = (lstat->redirects + lstat->authorize_fails +
0280             lstat->authenticate_fails + lstat->negotiate_fails +
0281             lstat->other_fails);
0282     spin_unlock(&lstat->lock);
0283
0284     return snprintf(page, PAGE_SIZE, "%u\n", fail_count);
0285 }
0286
0287 static ssize_t iscsi_stat_tgt_attr_last_fail_time_show(struct config_item *item,
0288         char *page)
0289 {
0290     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0291     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0292     u32 last_fail_time;
0293
0294     spin_lock(&lstat->lock);
0295     last_fail_time = lstat->last_fail_time ?
0296             (u32)(((u32)lstat->last_fail_time -
0297                 INITIAL_JIFFIES) * 100 / HZ) : 0;
0298     spin_unlock(&lstat->lock);
0299
0300     return snprintf(page, PAGE_SIZE, "%u\n", last_fail_time);
0301 }
0302
0303 static ssize_t iscsi_stat_tgt_attr_last_fail_type_show(struct config_item *item,
0304         char *page)
0305 {
0306     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0307     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0308     u32 last_fail_type;
0309
0310     spin_lock(&lstat->lock);
0311     last_fail_type = lstat->last_fail_type;
0312     spin_unlock(&lstat->lock);
0313
0314     return snprintf(page, PAGE_SIZE, "%u\n", last_fail_type);
0315 }
0316
0317 static ssize_t iscsi_stat_tgt_attr_fail_intr_name_show(struct config_item *item,
0318         char *page)
0319 {
0320     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0321     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0322     unsigned char buf[ISCSI_IQN_LEN];
0323
0324     spin_lock(&lstat->lock);
0325     snprintf(buf, ISCSI_IQN_LEN, "%s", lstat->last_intr_fail_name[0] ?
0326                 lstat->last_intr_fail_name : NONE);
0327     spin_unlock(&lstat->lock);
0328
0329     return snprintf(page, PAGE_SIZE, "%s\n", buf);
0330 }
0331
0332 static ssize_t iscsi_stat_tgt_attr_fail_intr_addr_type_show(struct config_item *item,
0333         char *page)
0334 {
0335     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0336     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0337     int ret;
0338
0339     spin_lock(&lstat->lock);
0340     if (lstat->last_intr_fail_ip_family == AF_INET6)
0341         ret = snprintf(page, PAGE_SIZE, "ipv6\n");
0342     else
0343         ret = snprintf(page, PAGE_SIZE, "ipv4\n");
0344     spin_unlock(&lstat->lock);
0345
0346     return ret;
0347 }
0348
0349 static ssize_t iscsi_stat_tgt_attr_fail_intr_addr_show(struct config_item *item,
0350         char *page)
0351 {
0352     struct iscsi_tiqn *tiqn = iscsi_tgt_attr_tiqn(item);
0353     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0354     int ret;
0355
0356     spin_lock(&lstat->lock);
0357     ret = snprintf(page, PAGE_SIZE, "%pISc\n", &lstat->last_intr_fail_sockaddr);
0358     spin_unlock(&lstat->lock);
0359
0360     return ret;
0361 }
0362
0363 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, inst);
0364 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, indx);
0365 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, login_fails);
0366 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, last_fail_time);
0367 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, last_fail_type);
0368 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_name);
0369 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_addr_type);
0370 CONFIGFS_ATTR_RO(iscsi_stat_tgt_attr_, fail_intr_addr);
0371
0372 static struct configfs_attribute *iscsi_stat_tgt_attr_attrs[] = {
0373     &iscsi_stat_tgt_attr_attr_inst,
0374     &iscsi_stat_tgt_attr_attr_indx,
0375     &iscsi_stat_tgt_attr_attr_login_fails,
0376     &iscsi_stat_tgt_attr_attr_last_fail_time,
0377     &iscsi_stat_tgt_attr_attr_last_fail_type,
0378     &iscsi_stat_tgt_attr_attr_fail_intr_name,
0379     &iscsi_stat_tgt_attr_attr_fail_intr_addr_type,
0380     &iscsi_stat_tgt_attr_attr_fail_intr_addr,
0381     NULL,
0382 };
0383
0384 const struct config_item_type iscsi_stat_tgt_attr_cit = {
0385     .ct_attrs       = iscsi_stat_tgt_attr_attrs,
0386     .ct_owner       = THIS_MODULE,
0387 };
0388
0389 /*
0390  * Target Login Stats Table
0391  */
0392 static struct iscsi_tiqn *iscsi_login_stat_tiqn(struct config_item *item)
0393 {
0394     struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
0395             struct iscsi_wwn_stat_grps, iscsi_login_stats_group);
0396     return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
0397 }
0398
0399 static ssize_t iscsi_stat_login_inst_show(struct config_item *item, char *page)
0400 {
0401     return snprintf(page, PAGE_SIZE, "%u\n",
0402         iscsi_login_stat_tiqn(item)->tiqn_index);
0403 }
0404
0405 static ssize_t iscsi_stat_login_indx_show(struct config_item *item,
0406         char *page)
0407 {
0408     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
0409 }
0410
0411 static ssize_t iscsi_stat_login_accepts_show(struct config_item *item,
0412         char *page)
0413 {
0414     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0415     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0416     ssize_t ret;
0417
0418     spin_lock(&lstat->lock);
0419     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->accepts);
0420     spin_unlock(&lstat->lock);
0421
0422     return ret;
0423 }
0424
0425 static ssize_t iscsi_stat_login_other_fails_show(struct config_item *item,
0426         char *page)
0427 {
0428     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0429     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0430     ssize_t ret;
0431
0432     spin_lock(&lstat->lock);
0433     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->other_fails);
0434     spin_unlock(&lstat->lock);
0435
0436     return ret;
0437 }
0438
0439 static ssize_t iscsi_stat_login_redirects_show(struct config_item *item,
0440         char *page)
0441 {
0442     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0443     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0444     ssize_t ret;
0445
0446     spin_lock(&lstat->lock);
0447     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->redirects);
0448     spin_unlock(&lstat->lock);
0449
0450     return ret;
0451 }
0452
0453 static ssize_t iscsi_stat_login_authorize_fails_show(struct config_item *item,
0454         char *page)
0455 {
0456     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0457     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0458     ssize_t ret;
0459
0460     spin_lock(&lstat->lock);
0461     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authorize_fails);
0462     spin_unlock(&lstat->lock);
0463
0464     return ret;
0465 }
0466
0467 static ssize_t iscsi_stat_login_authenticate_fails_show(
0468         struct config_item *item, char *page)
0469 {
0470     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0471     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0472     ssize_t ret;
0473
0474     spin_lock(&lstat->lock);
0475     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authenticate_fails);
0476     spin_unlock(&lstat->lock);
0477
0478     return ret;
0479 }
0480
0481 static ssize_t iscsi_stat_login_negotiate_fails_show(struct config_item *item,
0482         char *page)
0483 {
0484     struct iscsi_tiqn *tiqn = iscsi_login_stat_tiqn(item);
0485     struct iscsi_login_stats *lstat = &tiqn->login_stats;
0486     ssize_t ret;
0487
0488     spin_lock(&lstat->lock);
0489     ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->negotiate_fails);
0490     spin_unlock(&lstat->lock);
0491
0492     return ret;
0493 }
0494
0495 CONFIGFS_ATTR_RO(iscsi_stat_login_, inst);
0496 CONFIGFS_ATTR_RO(iscsi_stat_login_, indx);
0497 CONFIGFS_ATTR_RO(iscsi_stat_login_, accepts);
0498 CONFIGFS_ATTR_RO(iscsi_stat_login_, other_fails);
0499 CONFIGFS_ATTR_RO(iscsi_stat_login_, redirects);
0500 CONFIGFS_ATTR_RO(iscsi_stat_login_, authorize_fails);
0501 CONFIGFS_ATTR_RO(iscsi_stat_login_, authenticate_fails);
0502 CONFIGFS_ATTR_RO(iscsi_stat_login_, negotiate_fails);
0503
0504 static struct configfs_attribute *iscsi_stat_login_stats_attrs[] = {
0505     &iscsi_stat_login_attr_inst,
0506     &iscsi_stat_login_attr_indx,
0507     &iscsi_stat_login_attr_accepts,
0508     &iscsi_stat_login_attr_other_fails,
0509     &iscsi_stat_login_attr_redirects,
0510     &iscsi_stat_login_attr_authorize_fails,
0511     &iscsi_stat_login_attr_authenticate_fails,
0512     &iscsi_stat_login_attr_negotiate_fails,
0513     NULL,
0514 };
0515
0516 const struct config_item_type iscsi_stat_login_cit = {
0517     .ct_attrs       = iscsi_stat_login_stats_attrs,
0518     .ct_owner       = THIS_MODULE,
0519 };
0520
0521 /*
0522  * Target Logout Stats Table
0523  */
0524 static struct iscsi_tiqn *iscsi_logout_stat_tiqn(struct config_item *item)
0525 {
0526     struct iscsi_wwn_stat_grps *igrps = container_of(to_config_group(item),
0527             struct iscsi_wwn_stat_grps, iscsi_logout_stats_group);
0528     return container_of(igrps, struct iscsi_tiqn, tiqn_stat_grps);
0529 }
0530
0531 static ssize_t iscsi_stat_logout_inst_show(struct config_item *item, char *page)
0532 {
0533     return snprintf(page, PAGE_SIZE, "%u\n",
0534         iscsi_logout_stat_tiqn(item)->tiqn_index);
0535 }
0536
0537 static ssize_t iscsi_stat_logout_indx_show(struct config_item *item, char *page)
0538 {
0539     return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX);
0540 }
0541
0542 static ssize_t iscsi_stat_logout_normal_logouts_show(struct config_item *item,
0543         char *page)
0544 {
0545     struct iscsi_tiqn *tiqn = iscsi_logout_stat_tiqn(item);
0546     struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
0547
0548     return snprintf(page, PAGE_SIZE, "%u\n", lstats->normal_logouts);
0549 }
0550
0551 static ssize_t iscsi_stat_logout_abnormal_logouts_show(struct config_item *item,
0552         char *page)
0553 {
0554     struct iscsi_tiqn *tiqn = iscsi_logout_stat_tiqn(item);
0555     struct iscsi_logout_stats *lstats = &tiqn->logout_stats;
0556
0557     return snprintf(page, PAGE_SIZE, "%u\n", lstats->abnormal_logouts);
0558 }
0559
0560 CONFIGFS_ATTR_RO(iscsi_stat_logout_, inst);
0561 CONFIGFS_ATTR_RO(iscsi_stat_logout_, indx);
0562 CONFIGFS_ATTR_RO(iscsi_stat_logout_, normal_logouts);
0563 CONFIGFS_ATTR_RO(iscsi_stat_logout_, abnormal_logouts);
0564
0565 static struct configfs_attribute *iscsi_stat_logout_stats_attrs[] = {
0566     &iscsi_stat_logout_attr_inst,
0567     &iscsi_stat_logout_attr_indx,
0568     &iscsi_stat_logout_attr_normal_logouts,
0569     &iscsi_stat_logout_attr_abnormal_logouts,
0570     NULL,
0571 };
0572
0573 const struct config_item_type iscsi_stat_logout_cit = {
0574     .ct_attrs       = iscsi_stat_logout_stats_attrs,
0575     .ct_owner       = THIS_MODULE,
0576 };
0577
0578 /*
0579  * Session Stats Table
0580  */
0581 static struct iscsi_node_acl *iscsi_stat_nacl(struct config_item *item)
0582 {
0583     struct iscsi_node_stat_grps *igrps = container_of(to_config_group(item),
0584             struct iscsi_node_stat_grps, iscsi_sess_stats_group);
0585     return container_of(igrps, struct iscsi_node_acl, node_stat_grps);
0586 }
0587
0588 static ssize_t iscsi_stat_sess_inst_show(struct config_item *item, char *page)
0589 {
0590     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0591     struct se_wwn *wwn = acl->se_node_acl.se_tpg->se_tpg_wwn;
0592     struct iscsi_tiqn *tiqn = container_of(wwn,
0593             struct iscsi_tiqn, tiqn_wwn);
0594
0595     return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index);
0596 }
0597
0598 static ssize_t iscsi_stat_sess_node_show(struct config_item *item, char *page)
0599 {
0600     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0601     struct se_node_acl *se_nacl = &acl->se_node_acl;
0602     struct iscsit_session *sess;
0603     struct se_session *se_sess;
0604     ssize_t ret = 0;
0605
0606     spin_lock_bh(&se_nacl->nacl_sess_lock);
0607     se_sess = se_nacl->nacl_sess;
0608     if (se_sess) {
0609         sess = se_sess->fabric_sess_ptr;
0610         if (sess)
0611             ret = snprintf(page, PAGE_SIZE, "%u\n",
0612                 sess->sess_ops->SessionType ? 0 : ISCSI_NODE_INDEX);
0613     }
0614     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0615
0616     return ret;
0617 }
0618
0619 static ssize_t iscsi_stat_sess_indx_show(struct config_item *item, char *page)
0620 {
0621     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0622     struct se_node_acl *se_nacl = &acl->se_node_acl;
0623     struct iscsit_session *sess;
0624     struct se_session *se_sess;
0625     ssize_t ret = 0;
0626
0627     spin_lock_bh(&se_nacl->nacl_sess_lock);
0628     se_sess = se_nacl->nacl_sess;
0629     if (se_sess) {
0630         sess = se_sess->fabric_sess_ptr;
0631         if (sess)
0632             ret = snprintf(page, PAGE_SIZE, "%u\n",
0633                     sess->session_index);
0634     }
0635     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0636
0637     return ret;
0638 }
0639
0640 static ssize_t iscsi_stat_sess_cmd_pdus_show(struct config_item *item,
0641         char *page)
0642 {
0643     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0644     struct se_node_acl *se_nacl = &acl->se_node_acl;
0645     struct iscsit_session *sess;
0646     struct se_session *se_sess;
0647     ssize_t ret = 0;
0648
0649     spin_lock_bh(&se_nacl->nacl_sess_lock);
0650     se_sess = se_nacl->nacl_sess;
0651     if (se_sess) {
0652         sess = se_sess->fabric_sess_ptr;
0653         if (sess)
0654             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0655                        atomic_long_read(&sess->cmd_pdus));
0656     }
0657     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0658
0659     return ret;
0660 }
0661
0662 static ssize_t iscsi_stat_sess_rsp_pdus_show(struct config_item *item,
0663         char *page)
0664 {
0665     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0666     struct se_node_acl *se_nacl = &acl->se_node_acl;
0667     struct iscsit_session *sess;
0668     struct se_session *se_sess;
0669     ssize_t ret = 0;
0670
0671     spin_lock_bh(&se_nacl->nacl_sess_lock);
0672     se_sess = se_nacl->nacl_sess;
0673     if (se_sess) {
0674         sess = se_sess->fabric_sess_ptr;
0675         if (sess)
0676             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0677                        atomic_long_read(&sess->rsp_pdus));
0678     }
0679     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0680
0681     return ret;
0682 }
0683
0684 static ssize_t iscsi_stat_sess_txdata_octs_show(struct config_item *item,
0685         char *page)
0686 {
0687     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0688     struct se_node_acl *se_nacl = &acl->se_node_acl;
0689     struct iscsit_session *sess;
0690     struct se_session *se_sess;
0691     ssize_t ret = 0;
0692
0693     spin_lock_bh(&se_nacl->nacl_sess_lock);
0694     se_sess = se_nacl->nacl_sess;
0695     if (se_sess) {
0696         sess = se_sess->fabric_sess_ptr;
0697         if (sess)
0698             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0699                        atomic_long_read(&sess->tx_data_octets));
0700     }
0701     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0702
0703     return ret;
0704 }
0705
0706 static ssize_t iscsi_stat_sess_rxdata_octs_show(struct config_item *item,
0707         char *page)
0708 {
0709     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0710     struct se_node_acl *se_nacl = &acl->se_node_acl;
0711     struct iscsit_session *sess;
0712     struct se_session *se_sess;
0713     ssize_t ret = 0;
0714
0715     spin_lock_bh(&se_nacl->nacl_sess_lock);
0716     se_sess = se_nacl->nacl_sess;
0717     if (se_sess) {
0718         sess = se_sess->fabric_sess_ptr;
0719         if (sess)
0720             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0721                        atomic_long_read(&sess->rx_data_octets));
0722     }
0723     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0724
0725     return ret;
0726 }
0727
0728 static ssize_t iscsi_stat_sess_conn_digest_errors_show(struct config_item *item,
0729         char *page)
0730 {
0731     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0732     struct se_node_acl *se_nacl = &acl->se_node_acl;
0733     struct iscsit_session *sess;
0734     struct se_session *se_sess;
0735     ssize_t ret = 0;
0736
0737     spin_lock_bh(&se_nacl->nacl_sess_lock);
0738     se_sess = se_nacl->nacl_sess;
0739     if (se_sess) {
0740         sess = se_sess->fabric_sess_ptr;
0741         if (sess)
0742             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0743                        atomic_long_read(&sess->conn_digest_errors));
0744     }
0745     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0746
0747     return ret;
0748 }
0749
0750 static ssize_t iscsi_stat_sess_conn_timeout_errors_show(
0751         struct config_item *item, char *page)
0752 {
0753     struct iscsi_node_acl *acl = iscsi_stat_nacl(item);
0754     struct se_node_acl *se_nacl = &acl->se_node_acl;
0755     struct iscsit_session *sess;
0756     struct se_session *se_sess;
0757     ssize_t ret = 0;
0758
0759     spin_lock_bh(&se_nacl->nacl_sess_lock);
0760     se_sess = se_nacl->nacl_sess;
0761     if (se_sess) {
0762         sess = se_sess->fabric_sess_ptr;
0763         if (sess)
0764             ret = snprintf(page, PAGE_SIZE, "%lu\n",
0765                        atomic_long_read(&sess->conn_timeout_errors));
0766     }
0767     spin_unlock_bh(&se_nacl->nacl_sess_lock);
0768
0769     return ret;
0770 }
0771
0772 CONFIGFS_ATTR_RO(iscsi_stat_sess_, inst);
0773 CONFIGFS_ATTR_RO(iscsi_stat_sess_, node);
0774 CONFIGFS_ATTR_RO(iscsi_stat_sess_, indx);
0775 CONFIGFS_ATTR_RO(iscsi_stat_sess_, cmd_pdus);
0776 CONFIGFS_ATTR_RO(iscsi_stat_sess_, rsp_pdus);
0777 CONFIGFS_ATTR_RO(iscsi_stat_sess_, txdata_octs);
0778 CONFIGFS_ATTR_RO(iscsi_stat_sess_, rxdata_octs);
0779 CONFIGFS_ATTR_RO(iscsi_stat_sess_, conn_digest_errors);
0780 CONFIGFS_ATTR_RO(iscsi_stat_sess_, conn_timeout_errors);
0781
0782 static struct configfs_attribute *iscsi_stat_sess_stats_attrs[] = {
0783     &iscsi_stat_sess_attr_inst,
0784     &iscsi_stat_sess_attr_node,
0785     &iscsi_stat_sess_attr_indx,
0786     &iscsi_stat_sess_attr_cmd_pdus,
0787     &iscsi_stat_sess_attr_rsp_pdus,
0788     &iscsi_stat_sess_attr_txdata_octs,
0789     &iscsi_stat_sess_attr_rxdata_octs,
0790     &iscsi_stat_sess_attr_conn_digest_errors,
0791     &iscsi_stat_sess_attr_conn_timeout_errors,
0792     NULL,
0793 };
0794
0795 const struct config_item_type iscsi_stat_sess_cit = {
0796     .ct_attrs       = iscsi_stat_sess_stats_attrs,
0797     .ct_owner       = THIS_MODULE,
0798 };