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