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 unsigned char buf[32]; 433 434 spin_lock(&lstat->lock); 435 if (lstat->last_intr_fail_ip_family == AF_INET6) 436 snprintf(buf, 32, "[%s]", lstat->last_intr_fail_ip_addr); 437 else 438 snprintf(buf, 32, "%s", lstat->last_intr_fail_ip_addr); 439 spin_unlock(&lstat->lock); 440 441 return snprintf(page, PAGE_SIZE, "%s\n", buf); 442 } 443 ISCSI_STAT_TGT_ATTR_RO(fail_intr_addr); 444 445 CONFIGFS_EATTR_OPS(iscsi_stat_tgt_attr, iscsi_wwn_stat_grps, 446 iscsi_tgt_attr_group); 447 448 static struct configfs_attribute *iscsi_stat_tgt_attr_attrs[] = { 449 &iscsi_stat_tgt_attr_inst.attr, 450 &iscsi_stat_tgt_attr_indx.attr, 451 &iscsi_stat_tgt_attr_login_fails.attr, 452 &iscsi_stat_tgt_attr_last_fail_time.attr, 453 &iscsi_stat_tgt_attr_last_fail_type.attr, 454 &iscsi_stat_tgt_attr_fail_intr_name.attr, 455 &iscsi_stat_tgt_attr_fail_intr_addr_type.attr, 456 &iscsi_stat_tgt_attr_fail_intr_addr.attr, 457 NULL, 458 }; 459 460 static struct configfs_item_operations iscsi_stat_tgt_attr_item_ops = { 461 .show_attribute = iscsi_stat_tgt_attr_attr_show, 462 .store_attribute = iscsi_stat_tgt_attr_attr_store, 463 }; 464 465 struct config_item_type iscsi_stat_tgt_attr_cit = { 466 .ct_item_ops = &iscsi_stat_tgt_attr_item_ops, 467 .ct_attrs = iscsi_stat_tgt_attr_attrs, 468 .ct_owner = THIS_MODULE, 469 }; 470 471 /* 472 * Target Login Stats Table 473 */ 474 CONFIGFS_EATTR_STRUCT(iscsi_stat_login, iscsi_wwn_stat_grps); 475 #define ISCSI_STAT_LOGIN(_name, _mode) \ 476 static struct iscsi_stat_login_attribute \ 477 iscsi_stat_login_##_name = \ 478 __CONFIGFS_EATTR(_name, _mode, \ 479 iscsi_stat_login_show_attr_##_name, \ 480 iscsi_stat_login_store_attr_##_name); 481 482 #define ISCSI_STAT_LOGIN_RO(_name) \ 483 static struct iscsi_stat_login_attribute \ 484 iscsi_stat_login_##_name = \ 485 __CONFIGFS_EATTR_RO(_name, \ 486 iscsi_stat_login_show_attr_##_name); 487 488 static ssize_t iscsi_stat_login_show_attr_inst( 489 struct iscsi_wwn_stat_grps *igrps, char *page) 490 { 491 struct iscsi_tiqn *tiqn = container_of(igrps, 492 struct iscsi_tiqn, tiqn_stat_grps); 493 494 return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index); 495 } 496 ISCSI_STAT_LOGIN_RO(inst); 497 498 static ssize_t iscsi_stat_login_show_attr_indx( 499 struct iscsi_wwn_stat_grps *igrps, char *page) 500 { 501 return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX); 502 } 503 ISCSI_STAT_LOGIN_RO(indx); 504 505 static ssize_t iscsi_stat_login_show_attr_accepts( 506 struct iscsi_wwn_stat_grps *igrps, char *page) 507 { 508 struct iscsi_tiqn *tiqn = container_of(igrps, 509 struct iscsi_tiqn, tiqn_stat_grps); 510 struct iscsi_login_stats *lstat = &tiqn->login_stats; 511 ssize_t ret; 512 513 spin_lock(&lstat->lock); 514 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->accepts); 515 spin_unlock(&lstat->lock); 516 517 return ret; 518 } 519 ISCSI_STAT_LOGIN_RO(accepts); 520 521 static ssize_t iscsi_stat_login_show_attr_other_fails( 522 struct iscsi_wwn_stat_grps *igrps, char *page) 523 { 524 struct iscsi_tiqn *tiqn = container_of(igrps, 525 struct iscsi_tiqn, tiqn_stat_grps); 526 struct iscsi_login_stats *lstat = &tiqn->login_stats; 527 ssize_t ret; 528 529 spin_lock(&lstat->lock); 530 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->other_fails); 531 spin_unlock(&lstat->lock); 532 533 return ret; 534 } 535 ISCSI_STAT_LOGIN_RO(other_fails); 536 537 static ssize_t iscsi_stat_login_show_attr_redirects( 538 struct iscsi_wwn_stat_grps *igrps, char *page) 539 { 540 struct iscsi_tiqn *tiqn = container_of(igrps, 541 struct iscsi_tiqn, tiqn_stat_grps); 542 struct iscsi_login_stats *lstat = &tiqn->login_stats; 543 ssize_t ret; 544 545 spin_lock(&lstat->lock); 546 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->redirects); 547 spin_unlock(&lstat->lock); 548 549 return ret; 550 } 551 ISCSI_STAT_LOGIN_RO(redirects); 552 553 static ssize_t iscsi_stat_login_show_attr_authorize_fails( 554 struct iscsi_wwn_stat_grps *igrps, char *page) 555 { 556 struct iscsi_tiqn *tiqn = container_of(igrps, 557 struct iscsi_tiqn, tiqn_stat_grps); 558 struct iscsi_login_stats *lstat = &tiqn->login_stats; 559 ssize_t ret; 560 561 spin_lock(&lstat->lock); 562 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authorize_fails); 563 spin_unlock(&lstat->lock); 564 565 return ret; 566 } 567 ISCSI_STAT_LOGIN_RO(authorize_fails); 568 569 static ssize_t iscsi_stat_login_show_attr_authenticate_fails( 570 struct iscsi_wwn_stat_grps *igrps, char *page) 571 { 572 struct iscsi_tiqn *tiqn = container_of(igrps, 573 struct iscsi_tiqn, tiqn_stat_grps); 574 struct iscsi_login_stats *lstat = &tiqn->login_stats; 575 ssize_t ret; 576 577 spin_lock(&lstat->lock); 578 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->authenticate_fails); 579 spin_unlock(&lstat->lock); 580 581 return ret; 582 } 583 ISCSI_STAT_LOGIN_RO(authenticate_fails); 584 585 static ssize_t iscsi_stat_login_show_attr_negotiate_fails( 586 struct iscsi_wwn_stat_grps *igrps, char *page) 587 { 588 struct iscsi_tiqn *tiqn = container_of(igrps, 589 struct iscsi_tiqn, tiqn_stat_grps); 590 struct iscsi_login_stats *lstat = &tiqn->login_stats; 591 ssize_t ret; 592 593 spin_lock(&lstat->lock); 594 ret = snprintf(page, PAGE_SIZE, "%u\n", lstat->negotiate_fails); 595 spin_unlock(&lstat->lock); 596 597 return ret; 598 } 599 ISCSI_STAT_LOGIN_RO(negotiate_fails); 600 601 CONFIGFS_EATTR_OPS(iscsi_stat_login, iscsi_wwn_stat_grps, 602 iscsi_login_stats_group); 603 604 static struct configfs_attribute *iscsi_stat_login_stats_attrs[] = { 605 &iscsi_stat_login_inst.attr, 606 &iscsi_stat_login_indx.attr, 607 &iscsi_stat_login_accepts.attr, 608 &iscsi_stat_login_other_fails.attr, 609 &iscsi_stat_login_redirects.attr, 610 &iscsi_stat_login_authorize_fails.attr, 611 &iscsi_stat_login_authenticate_fails.attr, 612 &iscsi_stat_login_negotiate_fails.attr, 613 NULL, 614 }; 615 616 static struct configfs_item_operations iscsi_stat_login_stats_item_ops = { 617 .show_attribute = iscsi_stat_login_attr_show, 618 .store_attribute = iscsi_stat_login_attr_store, 619 }; 620 621 struct config_item_type iscsi_stat_login_cit = { 622 .ct_item_ops = &iscsi_stat_login_stats_item_ops, 623 .ct_attrs = iscsi_stat_login_stats_attrs, 624 .ct_owner = THIS_MODULE, 625 }; 626 627 /* 628 * Target Logout Stats Table 629 */ 630 631 CONFIGFS_EATTR_STRUCT(iscsi_stat_logout, iscsi_wwn_stat_grps); 632 #define ISCSI_STAT_LOGOUT(_name, _mode) \ 633 static struct iscsi_stat_logout_attribute \ 634 iscsi_stat_logout_##_name = \ 635 __CONFIGFS_EATTR(_name, _mode, \ 636 iscsi_stat_logout_show_attr_##_name, \ 637 iscsi_stat_logout_store_attr_##_name); 638 639 #define ISCSI_STAT_LOGOUT_RO(_name) \ 640 static struct iscsi_stat_logout_attribute \ 641 iscsi_stat_logout_##_name = \ 642 __CONFIGFS_EATTR_RO(_name, \ 643 iscsi_stat_logout_show_attr_##_name); 644 645 static ssize_t iscsi_stat_logout_show_attr_inst( 646 struct iscsi_wwn_stat_grps *igrps, char *page) 647 { 648 struct iscsi_tiqn *tiqn = container_of(igrps, 649 struct iscsi_tiqn, tiqn_stat_grps); 650 651 return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index); 652 } 653 ISCSI_STAT_LOGOUT_RO(inst); 654 655 static ssize_t iscsi_stat_logout_show_attr_indx( 656 struct iscsi_wwn_stat_grps *igrps, char *page) 657 { 658 return snprintf(page, PAGE_SIZE, "%u\n", ISCSI_NODE_INDEX); 659 } 660 ISCSI_STAT_LOGOUT_RO(indx); 661 662 static ssize_t iscsi_stat_logout_show_attr_normal_logouts( 663 struct iscsi_wwn_stat_grps *igrps, char *page) 664 { 665 struct iscsi_tiqn *tiqn = container_of(igrps, 666 struct iscsi_tiqn, tiqn_stat_grps); 667 struct iscsi_logout_stats *lstats = &tiqn->logout_stats; 668 669 return snprintf(page, PAGE_SIZE, "%u\n", lstats->normal_logouts); 670 } 671 ISCSI_STAT_LOGOUT_RO(normal_logouts); 672 673 static ssize_t iscsi_stat_logout_show_attr_abnormal_logouts( 674 struct iscsi_wwn_stat_grps *igrps, char *page) 675 { 676 struct iscsi_tiqn *tiqn = container_of(igrps, 677 struct iscsi_tiqn, tiqn_stat_grps); 678 struct iscsi_logout_stats *lstats = &tiqn->logout_stats; 679 680 return snprintf(page, PAGE_SIZE, "%u\n", lstats->abnormal_logouts); 681 } 682 ISCSI_STAT_LOGOUT_RO(abnormal_logouts); 683 684 CONFIGFS_EATTR_OPS(iscsi_stat_logout, iscsi_wwn_stat_grps, 685 iscsi_logout_stats_group); 686 687 static struct configfs_attribute *iscsi_stat_logout_stats_attrs[] = { 688 &iscsi_stat_logout_inst.attr, 689 &iscsi_stat_logout_indx.attr, 690 &iscsi_stat_logout_normal_logouts.attr, 691 &iscsi_stat_logout_abnormal_logouts.attr, 692 NULL, 693 }; 694 695 static struct configfs_item_operations iscsi_stat_logout_stats_item_ops = { 696 .show_attribute = iscsi_stat_logout_attr_show, 697 .store_attribute = iscsi_stat_logout_attr_store, 698 }; 699 700 struct config_item_type iscsi_stat_logout_cit = { 701 .ct_item_ops = &iscsi_stat_logout_stats_item_ops, 702 .ct_attrs = iscsi_stat_logout_stats_attrs, 703 .ct_owner = THIS_MODULE, 704 }; 705 706 /* 707 * Session Stats Table 708 */ 709 710 CONFIGFS_EATTR_STRUCT(iscsi_stat_sess, iscsi_node_stat_grps); 711 #define ISCSI_STAT_SESS(_name, _mode) \ 712 static struct iscsi_stat_sess_attribute \ 713 iscsi_stat_sess_##_name = \ 714 __CONFIGFS_EATTR(_name, _mode, \ 715 iscsi_stat_sess_show_attr_##_name, \ 716 iscsi_stat_sess_store_attr_##_name); 717 718 #define ISCSI_STAT_SESS_RO(_name) \ 719 static struct iscsi_stat_sess_attribute \ 720 iscsi_stat_sess_##_name = \ 721 __CONFIGFS_EATTR_RO(_name, \ 722 iscsi_stat_sess_show_attr_##_name); 723 724 static ssize_t iscsi_stat_sess_show_attr_inst( 725 struct iscsi_node_stat_grps *igrps, char *page) 726 { 727 struct iscsi_node_acl *acl = container_of(igrps, 728 struct iscsi_node_acl, node_stat_grps); 729 struct se_wwn *wwn = acl->se_node_acl.se_tpg->se_tpg_wwn; 730 struct iscsi_tiqn *tiqn = container_of(wwn, 731 struct iscsi_tiqn, tiqn_wwn); 732 733 return snprintf(page, PAGE_SIZE, "%u\n", tiqn->tiqn_index); 734 } 735 ISCSI_STAT_SESS_RO(inst); 736 737 static ssize_t iscsi_stat_sess_show_attr_node( 738 struct iscsi_node_stat_grps *igrps, char *page) 739 { 740 struct iscsi_node_acl *acl = container_of(igrps, 741 struct iscsi_node_acl, node_stat_grps); 742 struct se_node_acl *se_nacl = &acl->se_node_acl; 743 struct iscsi_session *sess; 744 struct se_session *se_sess; 745 ssize_t ret = 0; 746 747 spin_lock_bh(&se_nacl->nacl_sess_lock); 748 se_sess = se_nacl->nacl_sess; 749 if (se_sess) { 750 sess = se_sess->fabric_sess_ptr; 751 if (sess) 752 ret = snprintf(page, PAGE_SIZE, "%u\n", 753 sess->sess_ops->SessionType ? 0 : ISCSI_NODE_INDEX); 754 } 755 spin_unlock_bh(&se_nacl->nacl_sess_lock); 756 757 return ret; 758 } 759 ISCSI_STAT_SESS_RO(node); 760 761 static ssize_t iscsi_stat_sess_show_attr_indx( 762 struct iscsi_node_stat_grps *igrps, char *page) 763 { 764 struct iscsi_node_acl *acl = container_of(igrps, 765 struct iscsi_node_acl, node_stat_grps); 766 struct se_node_acl *se_nacl = &acl->se_node_acl; 767 struct iscsi_session *sess; 768 struct se_session *se_sess; 769 ssize_t ret = 0; 770 771 spin_lock_bh(&se_nacl->nacl_sess_lock); 772 se_sess = se_nacl->nacl_sess; 773 if (se_sess) { 774 sess = se_sess->fabric_sess_ptr; 775 if (sess) 776 ret = snprintf(page, PAGE_SIZE, "%u\n", 777 sess->session_index); 778 } 779 spin_unlock_bh(&se_nacl->nacl_sess_lock); 780 781 return ret; 782 } 783 ISCSI_STAT_SESS_RO(indx); 784 785 static ssize_t iscsi_stat_sess_show_attr_cmd_pdus( 786 struct iscsi_node_stat_grps *igrps, char *page) 787 { 788 struct iscsi_node_acl *acl = container_of(igrps, 789 struct iscsi_node_acl, node_stat_grps); 790 struct se_node_acl *se_nacl = &acl->se_node_acl; 791 struct iscsi_session *sess; 792 struct se_session *se_sess; 793 ssize_t ret = 0; 794 795 spin_lock_bh(&se_nacl->nacl_sess_lock); 796 se_sess = se_nacl->nacl_sess; 797 if (se_sess) { 798 sess = se_sess->fabric_sess_ptr; 799 if (sess) 800 ret = snprintf(page, PAGE_SIZE, "%u\n", sess->cmd_pdus); 801 } 802 spin_unlock_bh(&se_nacl->nacl_sess_lock); 803 804 return ret; 805 } 806 ISCSI_STAT_SESS_RO(cmd_pdus); 807 808 static ssize_t iscsi_stat_sess_show_attr_rsp_pdus( 809 struct iscsi_node_stat_grps *igrps, char *page) 810 { 811 struct iscsi_node_acl *acl = container_of(igrps, 812 struct iscsi_node_acl, node_stat_grps); 813 struct se_node_acl *se_nacl = &acl->se_node_acl; 814 struct iscsi_session *sess; 815 struct se_session *se_sess; 816 ssize_t ret = 0; 817 818 spin_lock_bh(&se_nacl->nacl_sess_lock); 819 se_sess = se_nacl->nacl_sess; 820 if (se_sess) { 821 sess = se_sess->fabric_sess_ptr; 822 if (sess) 823 ret = snprintf(page, PAGE_SIZE, "%u\n", sess->rsp_pdus); 824 } 825 spin_unlock_bh(&se_nacl->nacl_sess_lock); 826 827 return ret; 828 } 829 ISCSI_STAT_SESS_RO(rsp_pdus); 830 831 static ssize_t iscsi_stat_sess_show_attr_txdata_octs( 832 struct iscsi_node_stat_grps *igrps, char *page) 833 { 834 struct iscsi_node_acl *acl = container_of(igrps, 835 struct iscsi_node_acl, node_stat_grps); 836 struct se_node_acl *se_nacl = &acl->se_node_acl; 837 struct iscsi_session *sess; 838 struct se_session *se_sess; 839 ssize_t ret = 0; 840 841 spin_lock_bh(&se_nacl->nacl_sess_lock); 842 se_sess = se_nacl->nacl_sess; 843 if (se_sess) { 844 sess = se_sess->fabric_sess_ptr; 845 if (sess) 846 ret = snprintf(page, PAGE_SIZE, "%llu\n", 847 (unsigned long long)sess->tx_data_octets); 848 } 849 spin_unlock_bh(&se_nacl->nacl_sess_lock); 850 851 return ret; 852 } 853 ISCSI_STAT_SESS_RO(txdata_octs); 854 855 static ssize_t iscsi_stat_sess_show_attr_rxdata_octs( 856 struct iscsi_node_stat_grps *igrps, char *page) 857 { 858 struct iscsi_node_acl *acl = container_of(igrps, 859 struct iscsi_node_acl, node_stat_grps); 860 struct se_node_acl *se_nacl = &acl->se_node_acl; 861 struct iscsi_session *sess; 862 struct se_session *se_sess; 863 ssize_t ret = 0; 864 865 spin_lock_bh(&se_nacl->nacl_sess_lock); 866 se_sess = se_nacl->nacl_sess; 867 if (se_sess) { 868 sess = se_sess->fabric_sess_ptr; 869 if (sess) 870 ret = snprintf(page, PAGE_SIZE, "%llu\n", 871 (unsigned long long)sess->rx_data_octets); 872 } 873 spin_unlock_bh(&se_nacl->nacl_sess_lock); 874 875 return ret; 876 } 877 ISCSI_STAT_SESS_RO(rxdata_octs); 878 879 static ssize_t iscsi_stat_sess_show_attr_conn_digest_errors( 880 struct iscsi_node_stat_grps *igrps, char *page) 881 { 882 struct iscsi_node_acl *acl = container_of(igrps, 883 struct iscsi_node_acl, node_stat_grps); 884 struct se_node_acl *se_nacl = &acl->se_node_acl; 885 struct iscsi_session *sess; 886 struct se_session *se_sess; 887 ssize_t ret = 0; 888 889 spin_lock_bh(&se_nacl->nacl_sess_lock); 890 se_sess = se_nacl->nacl_sess; 891 if (se_sess) { 892 sess = se_sess->fabric_sess_ptr; 893 if (sess) 894 ret = snprintf(page, PAGE_SIZE, "%u\n", 895 sess->conn_digest_errors); 896 } 897 spin_unlock_bh(&se_nacl->nacl_sess_lock); 898 899 return ret; 900 } 901 ISCSI_STAT_SESS_RO(conn_digest_errors); 902 903 static ssize_t iscsi_stat_sess_show_attr_conn_timeout_errors( 904 struct iscsi_node_stat_grps *igrps, char *page) 905 { 906 struct iscsi_node_acl *acl = container_of(igrps, 907 struct iscsi_node_acl, node_stat_grps); 908 struct se_node_acl *se_nacl = &acl->se_node_acl; 909 struct iscsi_session *sess; 910 struct se_session *se_sess; 911 ssize_t ret = 0; 912 913 spin_lock_bh(&se_nacl->nacl_sess_lock); 914 se_sess = se_nacl->nacl_sess; 915 if (se_sess) { 916 sess = se_sess->fabric_sess_ptr; 917 if (sess) 918 ret = snprintf(page, PAGE_SIZE, "%u\n", 919 sess->conn_timeout_errors); 920 } 921 spin_unlock_bh(&se_nacl->nacl_sess_lock); 922 923 return ret; 924 } 925 ISCSI_STAT_SESS_RO(conn_timeout_errors); 926 927 CONFIGFS_EATTR_OPS(iscsi_stat_sess, iscsi_node_stat_grps, 928 iscsi_sess_stats_group); 929 930 static struct configfs_attribute *iscsi_stat_sess_stats_attrs[] = { 931 &iscsi_stat_sess_inst.attr, 932 &iscsi_stat_sess_node.attr, 933 &iscsi_stat_sess_indx.attr, 934 &iscsi_stat_sess_cmd_pdus.attr, 935 &iscsi_stat_sess_rsp_pdus.attr, 936 &iscsi_stat_sess_txdata_octs.attr, 937 &iscsi_stat_sess_rxdata_octs.attr, 938 &iscsi_stat_sess_conn_digest_errors.attr, 939 &iscsi_stat_sess_conn_timeout_errors.attr, 940 NULL, 941 }; 942 943 static struct configfs_item_operations iscsi_stat_sess_stats_item_ops = { 944 .show_attribute = iscsi_stat_sess_attr_show, 945 .store_attribute = iscsi_stat_sess_attr_store, 946 }; 947 948 struct config_item_type iscsi_stat_sess_cit = { 949 .ct_item_ops = &iscsi_stat_sess_stats_item_ops, 950 .ct_attrs = iscsi_stat_sess_stats_attrs, 951 .ct_owner = THIS_MODULE, 952 }; 953