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