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