drivers/target/iscsi/iscsi_target_stat.c

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