linux/drivers/target/target_core_stat.c
<<
>>
Prefs
   1/*******************************************************************************
   2 * Filename:  target_core_stat.c
   3 *
   4 * Copyright (c) 2011 Rising Tide Systems
   5 * Copyright (c) 2011 Linux-iSCSI.org
   6 *
   7 * Modern ConfigFS group context specific statistics based on original
   8 * target_core_mib.c code
   9 *
  10 * Copyright (c) 2006-2007 SBE, Inc.  All Rights Reserved.
  11 *
  12 * Nicholas A. Bellinger <nab@linux-iscsi.org>
  13 *
  14 * This program is free software; you can redistribute it and/or modify
  15 * it under the terms of the GNU General Public License as published by
  16 * the Free Software Foundation; either version 2 of the License, or
  17 * (at your option) any later version.
  18 *
  19 * This program is distributed in the hope that it will be useful,
  20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22 * GNU General Public License for more details.
  23 *
  24 * You should have received a copy of the GNU General Public License
  25 * along with this program; if not, write to the Free Software
  26 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27 *
  28 ******************************************************************************/
  29
  30#include <linux/kernel.h>
  31#include <linux/module.h>
  32#include <linux/delay.h>
  33#include <linux/timer.h>
  34#include <linux/string.h>
  35#include <linux/utsname.h>
  36#include <linux/proc_fs.h>
  37#include <linux/seq_file.h>
  38#include <linux/blkdev.h>
  39#include <linux/configfs.h>
  40#include <scsi/scsi.h>
  41#include <scsi/scsi_device.h>
  42#include <scsi/scsi_host.h>
  43
  44#include <target/target_core_base.h>
  45#include <target/target_core_backend.h>
  46#include <target/target_core_fabric.h>
  47#include <target/target_core_configfs.h>
  48#include <target/configfs_macros.h>
  49
  50#include "target_core_internal.h"
  51
  52#ifndef INITIAL_JIFFIES
  53#define INITIAL_JIFFIES ((unsigned long)(unsigned int) (-300*HZ))
  54#endif
  55
  56#define NONE            "None"
  57#define ISPRINT(a)   ((a >= ' ') && (a <= '~'))
  58
  59#define SCSI_LU_INDEX                   1
  60#define LU_COUNT                        1
  61
  62/*
  63 * SCSI Device Table
  64 */
  65
  66CONFIGFS_EATTR_STRUCT(target_stat_scsi_dev, se_dev_stat_grps);
  67#define DEV_STAT_SCSI_DEV_ATTR(_name, _mode)                            \
  68static struct target_stat_scsi_dev_attribute                            \
  69                        target_stat_scsi_dev_##_name =                  \
  70        __CONFIGFS_EATTR(_name, _mode,                                  \
  71        target_stat_scsi_dev_show_attr_##_name,                         \
  72        target_stat_scsi_dev_store_attr_##_name);
  73
  74#define DEV_STAT_SCSI_DEV_ATTR_RO(_name)                                \
  75static struct target_stat_scsi_dev_attribute                            \
  76                        target_stat_scsi_dev_##_name =                  \
  77        __CONFIGFS_EATTR_RO(_name,                                      \
  78        target_stat_scsi_dev_show_attr_##_name);
  79
  80static ssize_t target_stat_scsi_dev_show_attr_inst(
  81        struct se_dev_stat_grps *sgrps, char *page)
  82{
  83        struct se_subsystem_dev *se_subdev = container_of(sgrps,
  84                        struct se_subsystem_dev, dev_stat_grps);
  85        struct se_hba *hba = se_subdev->se_dev_hba;
  86        struct se_device *dev = se_subdev->se_dev_ptr;
  87
  88        if (!dev)
  89                return -ENODEV;
  90
  91        return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
  92}
  93DEV_STAT_SCSI_DEV_ATTR_RO(inst);
  94
  95static ssize_t target_stat_scsi_dev_show_attr_indx(
  96        struct se_dev_stat_grps *sgrps, char *page)
  97{
  98        struct se_subsystem_dev *se_subdev = container_of(sgrps,
  99                        struct se_subsystem_dev, dev_stat_grps);
 100        struct se_device *dev = se_subdev->se_dev_ptr;
 101
 102        if (!dev)
 103                return -ENODEV;
 104
 105        return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 106}
 107DEV_STAT_SCSI_DEV_ATTR_RO(indx);
 108
 109static ssize_t target_stat_scsi_dev_show_attr_role(
 110        struct se_dev_stat_grps *sgrps, char *page)
 111{
 112        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 113                        struct se_subsystem_dev, dev_stat_grps);
 114        struct se_device *dev = se_subdev->se_dev_ptr;
 115
 116        if (!dev)
 117                return -ENODEV;
 118
 119        return snprintf(page, PAGE_SIZE, "Target\n");
 120}
 121DEV_STAT_SCSI_DEV_ATTR_RO(role);
 122
 123static ssize_t target_stat_scsi_dev_show_attr_ports(
 124        struct se_dev_stat_grps *sgrps, char *page)
 125{
 126        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 127                        struct se_subsystem_dev, dev_stat_grps);
 128        struct se_device *dev = se_subdev->se_dev_ptr;
 129
 130        if (!dev)
 131                return -ENODEV;
 132
 133        return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_port_count);
 134}
 135DEV_STAT_SCSI_DEV_ATTR_RO(ports);
 136
 137CONFIGFS_EATTR_OPS(target_stat_scsi_dev, se_dev_stat_grps, scsi_dev_group);
 138
 139static struct configfs_attribute *target_stat_scsi_dev_attrs[] = {
 140        &target_stat_scsi_dev_inst.attr,
 141        &target_stat_scsi_dev_indx.attr,
 142        &target_stat_scsi_dev_role.attr,
 143        &target_stat_scsi_dev_ports.attr,
 144        NULL,
 145};
 146
 147static struct configfs_item_operations target_stat_scsi_dev_attrib_ops = {
 148        .show_attribute         = target_stat_scsi_dev_attr_show,
 149        .store_attribute        = target_stat_scsi_dev_attr_store,
 150};
 151
 152static struct config_item_type target_stat_scsi_dev_cit = {
 153        .ct_item_ops            = &target_stat_scsi_dev_attrib_ops,
 154        .ct_attrs               = target_stat_scsi_dev_attrs,
 155        .ct_owner               = THIS_MODULE,
 156};
 157
 158/*
 159 * SCSI Target Device Table
 160 */
 161
 162CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_dev, se_dev_stat_grps);
 163#define DEV_STAT_SCSI_TGT_DEV_ATTR(_name, _mode)                        \
 164static struct target_stat_scsi_tgt_dev_attribute                        \
 165                        target_stat_scsi_tgt_dev_##_name =              \
 166        __CONFIGFS_EATTR(_name, _mode,                                  \
 167        target_stat_scsi_tgt_dev_show_attr_##_name,                     \
 168        target_stat_scsi_tgt_dev_store_attr_##_name);
 169
 170#define DEV_STAT_SCSI_TGT_DEV_ATTR_RO(_name)                            \
 171static struct target_stat_scsi_tgt_dev_attribute                        \
 172                        target_stat_scsi_tgt_dev_##_name =              \
 173        __CONFIGFS_EATTR_RO(_name,                                      \
 174        target_stat_scsi_tgt_dev_show_attr_##_name);
 175
 176static ssize_t target_stat_scsi_tgt_dev_show_attr_inst(
 177        struct se_dev_stat_grps *sgrps, char *page)
 178{
 179        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 180                        struct se_subsystem_dev, dev_stat_grps);
 181        struct se_hba *hba = se_subdev->se_dev_hba;
 182        struct se_device *dev = se_subdev->se_dev_ptr;
 183
 184        if (!dev)
 185                return -ENODEV;
 186
 187        return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 188}
 189DEV_STAT_SCSI_TGT_DEV_ATTR_RO(inst);
 190
 191static ssize_t target_stat_scsi_tgt_dev_show_attr_indx(
 192        struct se_dev_stat_grps *sgrps, char *page)
 193{
 194        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 195                        struct se_subsystem_dev, dev_stat_grps);
 196        struct se_device *dev = se_subdev->se_dev_ptr;
 197
 198        if (!dev)
 199                return -ENODEV;
 200
 201        return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 202}
 203DEV_STAT_SCSI_TGT_DEV_ATTR_RO(indx);
 204
 205static ssize_t target_stat_scsi_tgt_dev_show_attr_num_lus(
 206        struct se_dev_stat_grps *sgrps, char *page)
 207{
 208        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 209                        struct se_subsystem_dev, dev_stat_grps);
 210        struct se_device *dev = se_subdev->se_dev_ptr;
 211
 212        if (!dev)
 213                return -ENODEV;
 214
 215        return snprintf(page, PAGE_SIZE, "%u\n", LU_COUNT);
 216}
 217DEV_STAT_SCSI_TGT_DEV_ATTR_RO(num_lus);
 218
 219static ssize_t target_stat_scsi_tgt_dev_show_attr_status(
 220        struct se_dev_stat_grps *sgrps, char *page)
 221{
 222        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 223                        struct se_subsystem_dev, dev_stat_grps);
 224        struct se_device *dev = se_subdev->se_dev_ptr;
 225        char status[16];
 226
 227        if (!dev)
 228                return -ENODEV;
 229
 230        switch (dev->dev_status) {
 231        case TRANSPORT_DEVICE_ACTIVATED:
 232                strcpy(status, "activated");
 233                break;
 234        case TRANSPORT_DEVICE_DEACTIVATED:
 235                strcpy(status, "deactivated");
 236                break;
 237        case TRANSPORT_DEVICE_SHUTDOWN:
 238                strcpy(status, "shutdown");
 239                break;
 240        case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 241        case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 242                strcpy(status, "offline");
 243                break;
 244        default:
 245                sprintf(status, "unknown(%d)", dev->dev_status);
 246                break;
 247        }
 248
 249        return snprintf(page, PAGE_SIZE, "%s\n", status);
 250}
 251DEV_STAT_SCSI_TGT_DEV_ATTR_RO(status);
 252
 253static ssize_t target_stat_scsi_tgt_dev_show_attr_non_access_lus(
 254        struct se_dev_stat_grps *sgrps, char *page)
 255{
 256        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 257                        struct se_subsystem_dev, dev_stat_grps);
 258        struct se_device *dev = se_subdev->se_dev_ptr;
 259        int non_accessible_lus;
 260
 261        if (!dev)
 262                return -ENODEV;
 263
 264        switch (dev->dev_status) {
 265        case TRANSPORT_DEVICE_ACTIVATED:
 266                non_accessible_lus = 0;
 267                break;
 268        case TRANSPORT_DEVICE_DEACTIVATED:
 269        case TRANSPORT_DEVICE_SHUTDOWN:
 270        case TRANSPORT_DEVICE_OFFLINE_ACTIVATED:
 271        case TRANSPORT_DEVICE_OFFLINE_DEACTIVATED:
 272        default:
 273                non_accessible_lus = 1;
 274                break;
 275        }
 276
 277        return snprintf(page, PAGE_SIZE, "%u\n", non_accessible_lus);
 278}
 279DEV_STAT_SCSI_TGT_DEV_ATTR_RO(non_access_lus);
 280
 281static ssize_t target_stat_scsi_tgt_dev_show_attr_resets(
 282        struct se_dev_stat_grps *sgrps, char *page)
 283{
 284        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 285                        struct se_subsystem_dev, dev_stat_grps);
 286        struct se_device *dev = se_subdev->se_dev_ptr;
 287
 288        if (!dev)
 289                return -ENODEV;
 290
 291        return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 292}
 293DEV_STAT_SCSI_TGT_DEV_ATTR_RO(resets);
 294
 295
 296CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_dev, se_dev_stat_grps, scsi_tgt_dev_group);
 297
 298static struct configfs_attribute *target_stat_scsi_tgt_dev_attrs[] = {
 299        &target_stat_scsi_tgt_dev_inst.attr,
 300        &target_stat_scsi_tgt_dev_indx.attr,
 301        &target_stat_scsi_tgt_dev_num_lus.attr,
 302        &target_stat_scsi_tgt_dev_status.attr,
 303        &target_stat_scsi_tgt_dev_non_access_lus.attr,
 304        &target_stat_scsi_tgt_dev_resets.attr,
 305        NULL,
 306};
 307
 308static struct configfs_item_operations target_stat_scsi_tgt_dev_attrib_ops = {
 309        .show_attribute         = target_stat_scsi_tgt_dev_attr_show,
 310        .store_attribute        = target_stat_scsi_tgt_dev_attr_store,
 311};
 312
 313static struct config_item_type target_stat_scsi_tgt_dev_cit = {
 314        .ct_item_ops            = &target_stat_scsi_tgt_dev_attrib_ops,
 315        .ct_attrs               = target_stat_scsi_tgt_dev_attrs,
 316        .ct_owner               = THIS_MODULE,
 317};
 318
 319/*
 320 * SCSI Logical Unit Table
 321 */
 322
 323CONFIGFS_EATTR_STRUCT(target_stat_scsi_lu, se_dev_stat_grps);
 324#define DEV_STAT_SCSI_LU_ATTR(_name, _mode)                             \
 325static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 326        __CONFIGFS_EATTR(_name, _mode,                                  \
 327        target_stat_scsi_lu_show_attr_##_name,                          \
 328        target_stat_scsi_lu_store_attr_##_name);
 329
 330#define DEV_STAT_SCSI_LU_ATTR_RO(_name)                                 \
 331static struct target_stat_scsi_lu_attribute target_stat_scsi_lu_##_name = \
 332        __CONFIGFS_EATTR_RO(_name,                                      \
 333        target_stat_scsi_lu_show_attr_##_name);
 334
 335static ssize_t target_stat_scsi_lu_show_attr_inst(
 336        struct se_dev_stat_grps *sgrps, char *page)
 337{
 338        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 339                        struct se_subsystem_dev, dev_stat_grps);
 340        struct se_hba *hba = se_subdev->se_dev_hba;
 341        struct se_device *dev = se_subdev->se_dev_ptr;
 342
 343        if (!dev)
 344                return -ENODEV;
 345
 346        return snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 347}
 348DEV_STAT_SCSI_LU_ATTR_RO(inst);
 349
 350static ssize_t target_stat_scsi_lu_show_attr_dev(
 351        struct se_dev_stat_grps *sgrps, char *page)
 352{
 353        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 354                        struct se_subsystem_dev, dev_stat_grps);
 355        struct se_device *dev = se_subdev->se_dev_ptr;
 356
 357        if (!dev)
 358                return -ENODEV;
 359
 360        return snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 361}
 362DEV_STAT_SCSI_LU_ATTR_RO(dev);
 363
 364static ssize_t target_stat_scsi_lu_show_attr_indx(
 365        struct se_dev_stat_grps *sgrps, char *page)
 366{
 367        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 368                        struct se_subsystem_dev, dev_stat_grps);
 369        struct se_device *dev = se_subdev->se_dev_ptr;
 370
 371        if (!dev)
 372                return -ENODEV;
 373
 374        return snprintf(page, PAGE_SIZE, "%u\n", SCSI_LU_INDEX);
 375}
 376DEV_STAT_SCSI_LU_ATTR_RO(indx);
 377
 378static ssize_t target_stat_scsi_lu_show_attr_lun(
 379        struct se_dev_stat_grps *sgrps, char *page)
 380{
 381        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 382                        struct se_subsystem_dev, dev_stat_grps);
 383        struct se_device *dev = se_subdev->se_dev_ptr;
 384
 385        if (!dev)
 386                return -ENODEV;
 387        /* FIXME: scsiLuDefaultLun */
 388        return snprintf(page, PAGE_SIZE, "%llu\n", (unsigned long long)0);
 389}
 390DEV_STAT_SCSI_LU_ATTR_RO(lun);
 391
 392static ssize_t target_stat_scsi_lu_show_attr_lu_name(
 393        struct se_dev_stat_grps *sgrps, char *page)
 394{
 395        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 396                        struct se_subsystem_dev, dev_stat_grps);
 397        struct se_device *dev = se_subdev->se_dev_ptr;
 398
 399        if (!dev)
 400                return -ENODEV;
 401        /* scsiLuWwnName */
 402        return snprintf(page, PAGE_SIZE, "%s\n",
 403                        (strlen(dev->se_sub_dev->t10_wwn.unit_serial)) ?
 404                        dev->se_sub_dev->t10_wwn.unit_serial : "None");
 405}
 406DEV_STAT_SCSI_LU_ATTR_RO(lu_name);
 407
 408static ssize_t target_stat_scsi_lu_show_attr_vend(
 409        struct se_dev_stat_grps *sgrps, char *page)
 410{
 411        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 412                        struct se_subsystem_dev, dev_stat_grps);
 413        struct se_device *dev = se_subdev->se_dev_ptr;
 414        int i;
 415        char str[sizeof(dev->se_sub_dev->t10_wwn.vendor)+1];
 416
 417        if (!dev)
 418                return -ENODEV;
 419
 420        /* scsiLuVendorId */
 421        for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 422                str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.vendor[i]) ?
 423                        dev->se_sub_dev->t10_wwn.vendor[i] : ' ';
 424        str[i] = '\0';
 425        return snprintf(page, PAGE_SIZE, "%s\n", str);
 426}
 427DEV_STAT_SCSI_LU_ATTR_RO(vend);
 428
 429static ssize_t target_stat_scsi_lu_show_attr_prod(
 430        struct se_dev_stat_grps *sgrps, char *page)
 431{
 432        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 433                        struct se_subsystem_dev, dev_stat_grps);
 434        struct se_device *dev = se_subdev->se_dev_ptr;
 435        int i;
 436        char str[sizeof(dev->se_sub_dev->t10_wwn.model)+1];
 437
 438        if (!dev)
 439                return -ENODEV;
 440
 441        /* scsiLuProductId */
 442        for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.vendor); i++)
 443                str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.model[i]) ?
 444                        dev->se_sub_dev->t10_wwn.model[i] : ' ';
 445        str[i] = '\0';
 446        return snprintf(page, PAGE_SIZE, "%s\n", str);
 447}
 448DEV_STAT_SCSI_LU_ATTR_RO(prod);
 449
 450static ssize_t target_stat_scsi_lu_show_attr_rev(
 451        struct se_dev_stat_grps *sgrps, char *page)
 452{
 453        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 454                        struct se_subsystem_dev, dev_stat_grps);
 455        struct se_device *dev = se_subdev->se_dev_ptr;
 456        int i;
 457        char str[sizeof(dev->se_sub_dev->t10_wwn.revision)+1];
 458
 459        if (!dev)
 460                return -ENODEV;
 461
 462        /* scsiLuRevisionId */
 463        for (i = 0; i < sizeof(dev->se_sub_dev->t10_wwn.revision); i++)
 464                str[i] = ISPRINT(dev->se_sub_dev->t10_wwn.revision[i]) ?
 465                        dev->se_sub_dev->t10_wwn.revision[i] : ' ';
 466        str[i] = '\0';
 467        return snprintf(page, PAGE_SIZE, "%s\n", str);
 468}
 469DEV_STAT_SCSI_LU_ATTR_RO(rev);
 470
 471static ssize_t target_stat_scsi_lu_show_attr_dev_type(
 472        struct se_dev_stat_grps *sgrps, char *page)
 473{
 474        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 475                        struct se_subsystem_dev, dev_stat_grps);
 476        struct se_device *dev = se_subdev->se_dev_ptr;
 477
 478        if (!dev)
 479                return -ENODEV;
 480
 481        /* scsiLuPeripheralType */
 482        return snprintf(page, PAGE_SIZE, "%u\n",
 483                        dev->transport->get_device_type(dev));
 484}
 485DEV_STAT_SCSI_LU_ATTR_RO(dev_type);
 486
 487static ssize_t target_stat_scsi_lu_show_attr_status(
 488        struct se_dev_stat_grps *sgrps, char *page)
 489{
 490        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 491                        struct se_subsystem_dev, dev_stat_grps);
 492        struct se_device *dev = se_subdev->se_dev_ptr;
 493
 494        if (!dev)
 495                return -ENODEV;
 496
 497        /* scsiLuStatus */
 498        return snprintf(page, PAGE_SIZE, "%s\n",
 499                (dev->dev_status == TRANSPORT_DEVICE_ACTIVATED) ?
 500                "available" : "notavailable");
 501}
 502DEV_STAT_SCSI_LU_ATTR_RO(status);
 503
 504static ssize_t target_stat_scsi_lu_show_attr_state_bit(
 505        struct se_dev_stat_grps *sgrps, char *page)
 506{
 507        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 508                        struct se_subsystem_dev, dev_stat_grps);
 509        struct se_device *dev = se_subdev->se_dev_ptr;
 510
 511        if (!dev)
 512                return -ENODEV;
 513
 514        /* scsiLuState */
 515        return snprintf(page, PAGE_SIZE, "exposed\n");
 516}
 517DEV_STAT_SCSI_LU_ATTR_RO(state_bit);
 518
 519static ssize_t target_stat_scsi_lu_show_attr_num_cmds(
 520        struct se_dev_stat_grps *sgrps, char *page)
 521{
 522        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 523                        struct se_subsystem_dev, dev_stat_grps);
 524        struct se_device *dev = se_subdev->se_dev_ptr;
 525
 526        if (!dev)
 527                return -ENODEV;
 528
 529        /* scsiLuNumCommands */
 530        return snprintf(page, PAGE_SIZE, "%llu\n",
 531                        (unsigned long long)dev->num_cmds);
 532}
 533DEV_STAT_SCSI_LU_ATTR_RO(num_cmds);
 534
 535static ssize_t target_stat_scsi_lu_show_attr_read_mbytes(
 536        struct se_dev_stat_grps *sgrps, char *page)
 537{
 538        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 539                        struct se_subsystem_dev, dev_stat_grps);
 540        struct se_device *dev = se_subdev->se_dev_ptr;
 541
 542        if (!dev)
 543                return -ENODEV;
 544
 545        /* scsiLuReadMegaBytes */
 546        return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->read_bytes >> 20));
 547}
 548DEV_STAT_SCSI_LU_ATTR_RO(read_mbytes);
 549
 550static ssize_t target_stat_scsi_lu_show_attr_write_mbytes(
 551        struct se_dev_stat_grps *sgrps, char *page)
 552{
 553        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 554                        struct se_subsystem_dev, dev_stat_grps);
 555        struct se_device *dev = se_subdev->se_dev_ptr;
 556
 557        if (!dev)
 558                return -ENODEV;
 559
 560        /* scsiLuWrittenMegaBytes */
 561        return snprintf(page, PAGE_SIZE, "%u\n", (u32)(dev->write_bytes >> 20));
 562}
 563DEV_STAT_SCSI_LU_ATTR_RO(write_mbytes);
 564
 565static ssize_t target_stat_scsi_lu_show_attr_resets(
 566        struct se_dev_stat_grps *sgrps, char *page)
 567{
 568        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 569                        struct se_subsystem_dev, dev_stat_grps);
 570        struct se_device *dev = se_subdev->se_dev_ptr;
 571
 572        if (!dev)
 573                return -ENODEV;
 574
 575        /* scsiLuInResets */
 576        return snprintf(page, PAGE_SIZE, "%u\n", dev->num_resets);
 577}
 578DEV_STAT_SCSI_LU_ATTR_RO(resets);
 579
 580static ssize_t target_stat_scsi_lu_show_attr_full_stat(
 581        struct se_dev_stat_grps *sgrps, char *page)
 582{
 583        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 584                        struct se_subsystem_dev, dev_stat_grps);
 585        struct se_device *dev = se_subdev->se_dev_ptr;
 586
 587        if (!dev)
 588                return -ENODEV;
 589
 590        /* FIXME: scsiLuOutTaskSetFullStatus */
 591        return snprintf(page, PAGE_SIZE, "%u\n", 0);
 592}
 593DEV_STAT_SCSI_LU_ATTR_RO(full_stat);
 594
 595static ssize_t target_stat_scsi_lu_show_attr_hs_num_cmds(
 596        struct se_dev_stat_grps *sgrps, char *page)
 597{
 598        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 599                        struct se_subsystem_dev, dev_stat_grps);
 600        struct se_device *dev = se_subdev->se_dev_ptr;
 601
 602        if (!dev)
 603                return -ENODEV;
 604
 605        /* FIXME: scsiLuHSInCommands */
 606        return snprintf(page, PAGE_SIZE, "%u\n", 0);
 607}
 608DEV_STAT_SCSI_LU_ATTR_RO(hs_num_cmds);
 609
 610static ssize_t target_stat_scsi_lu_show_attr_creation_time(
 611        struct se_dev_stat_grps *sgrps, char *page)
 612{
 613        struct se_subsystem_dev *se_subdev = container_of(sgrps,
 614                        struct se_subsystem_dev, dev_stat_grps);
 615        struct se_device *dev = se_subdev->se_dev_ptr;
 616
 617        if (!dev)
 618                return -ENODEV;
 619
 620        /* scsiLuCreationTime */
 621        return snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)dev->creation_time -
 622                                INITIAL_JIFFIES) * 100 / HZ));
 623}
 624DEV_STAT_SCSI_LU_ATTR_RO(creation_time);
 625
 626CONFIGFS_EATTR_OPS(target_stat_scsi_lu, se_dev_stat_grps, scsi_lu_group);
 627
 628static struct configfs_attribute *target_stat_scsi_lu_attrs[] = {
 629        &target_stat_scsi_lu_inst.attr,
 630        &target_stat_scsi_lu_dev.attr,
 631        &target_stat_scsi_lu_indx.attr,
 632        &target_stat_scsi_lu_lun.attr,
 633        &target_stat_scsi_lu_lu_name.attr,
 634        &target_stat_scsi_lu_vend.attr,
 635        &target_stat_scsi_lu_prod.attr,
 636        &target_stat_scsi_lu_rev.attr,
 637        &target_stat_scsi_lu_dev_type.attr,
 638        &target_stat_scsi_lu_status.attr,
 639        &target_stat_scsi_lu_state_bit.attr,
 640        &target_stat_scsi_lu_num_cmds.attr,
 641        &target_stat_scsi_lu_read_mbytes.attr,
 642        &target_stat_scsi_lu_write_mbytes.attr,
 643        &target_stat_scsi_lu_resets.attr,
 644        &target_stat_scsi_lu_full_stat.attr,
 645        &target_stat_scsi_lu_hs_num_cmds.attr,
 646        &target_stat_scsi_lu_creation_time.attr,
 647        NULL,
 648};
 649
 650static struct configfs_item_operations target_stat_scsi_lu_attrib_ops = {
 651        .show_attribute         = target_stat_scsi_lu_attr_show,
 652        .store_attribute        = target_stat_scsi_lu_attr_store,
 653};
 654
 655static struct config_item_type target_stat_scsi_lu_cit = {
 656        .ct_item_ops            = &target_stat_scsi_lu_attrib_ops,
 657        .ct_attrs               = target_stat_scsi_lu_attrs,
 658        .ct_owner               = THIS_MODULE,
 659};
 660
 661/*
 662 * Called from target_core_configfs.c:target_core_make_subdev() to setup
 663 * the target statistics groups + configfs CITs located in target_core_stat.c
 664 */
 665void target_stat_setup_dev_default_groups(struct se_subsystem_dev *se_subdev)
 666{
 667        struct config_group *dev_stat_grp = &se_subdev->dev_stat_grps.stat_group;
 668
 669        config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_dev_group,
 670                        "scsi_dev", &target_stat_scsi_dev_cit);
 671        config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_tgt_dev_group,
 672                        "scsi_tgt_dev", &target_stat_scsi_tgt_dev_cit);
 673        config_group_init_type_name(&se_subdev->dev_stat_grps.scsi_lu_group,
 674                        "scsi_lu", &target_stat_scsi_lu_cit);
 675
 676        dev_stat_grp->default_groups[0] = &se_subdev->dev_stat_grps.scsi_dev_group;
 677        dev_stat_grp->default_groups[1] = &se_subdev->dev_stat_grps.scsi_tgt_dev_group;
 678        dev_stat_grp->default_groups[2] = &se_subdev->dev_stat_grps.scsi_lu_group;
 679        dev_stat_grp->default_groups[3] = NULL;
 680}
 681
 682/*
 683 * SCSI Port Table
 684 */
 685
 686CONFIGFS_EATTR_STRUCT(target_stat_scsi_port, se_port_stat_grps);
 687#define DEV_STAT_SCSI_PORT_ATTR(_name, _mode)                           \
 688static struct target_stat_scsi_port_attribute                           \
 689                        target_stat_scsi_port_##_name =                 \
 690        __CONFIGFS_EATTR(_name, _mode,                                  \
 691        target_stat_scsi_port_show_attr_##_name,                        \
 692        target_stat_scsi_port_store_attr_##_name);
 693
 694#define DEV_STAT_SCSI_PORT_ATTR_RO(_name)                               \
 695static struct target_stat_scsi_port_attribute                           \
 696                        target_stat_scsi_port_##_name =                 \
 697        __CONFIGFS_EATTR_RO(_name,                                      \
 698        target_stat_scsi_port_show_attr_##_name);
 699
 700static ssize_t target_stat_scsi_port_show_attr_inst(
 701        struct se_port_stat_grps *pgrps, char *page)
 702{
 703        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 704        struct se_port *sep;
 705        struct se_device *dev = lun->lun_se_dev;
 706        struct se_hba *hba;
 707        ssize_t ret;
 708
 709        spin_lock(&lun->lun_sep_lock);
 710        sep = lun->lun_sep;
 711        if (!sep) {
 712                spin_unlock(&lun->lun_sep_lock);
 713                return -ENODEV;
 714        }
 715        hba = dev->se_hba;
 716        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 717        spin_unlock(&lun->lun_sep_lock);
 718        return ret;
 719}
 720DEV_STAT_SCSI_PORT_ATTR_RO(inst);
 721
 722static ssize_t target_stat_scsi_port_show_attr_dev(
 723        struct se_port_stat_grps *pgrps, char *page)
 724{
 725        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 726        struct se_port *sep;
 727        struct se_device *dev = lun->lun_se_dev;
 728        ssize_t ret;
 729
 730        spin_lock(&lun->lun_sep_lock);
 731        sep = lun->lun_sep;
 732        if (!sep) {
 733                spin_unlock(&lun->lun_sep_lock);
 734                return -ENODEV;
 735        }
 736        ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 737        spin_unlock(&lun->lun_sep_lock);
 738        return ret;
 739}
 740DEV_STAT_SCSI_PORT_ATTR_RO(dev);
 741
 742static ssize_t target_stat_scsi_port_show_attr_indx(
 743        struct se_port_stat_grps *pgrps, char *page)
 744{
 745        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 746        struct se_port *sep;
 747        ssize_t ret;
 748
 749        spin_lock(&lun->lun_sep_lock);
 750        sep = lun->lun_sep;
 751        if (!sep) {
 752                spin_unlock(&lun->lun_sep_lock);
 753                return -ENODEV;
 754        }
 755        ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 756        spin_unlock(&lun->lun_sep_lock);
 757        return ret;
 758}
 759DEV_STAT_SCSI_PORT_ATTR_RO(indx);
 760
 761static ssize_t target_stat_scsi_port_show_attr_role(
 762        struct se_port_stat_grps *pgrps, char *page)
 763{
 764        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 765        struct se_device *dev = lun->lun_se_dev;
 766        struct se_port *sep;
 767        ssize_t ret;
 768
 769        if (!dev)
 770                return -ENODEV;
 771
 772        spin_lock(&lun->lun_sep_lock);
 773        sep = lun->lun_sep;
 774        if (!sep) {
 775                spin_unlock(&lun->lun_sep_lock);
 776                return -ENODEV;
 777        }
 778        ret = snprintf(page, PAGE_SIZE, "%s%u\n", "Device", dev->dev_index);
 779        spin_unlock(&lun->lun_sep_lock);
 780        return ret;
 781}
 782DEV_STAT_SCSI_PORT_ATTR_RO(role);
 783
 784static ssize_t target_stat_scsi_port_show_attr_busy_count(
 785        struct se_port_stat_grps *pgrps, char *page)
 786{
 787        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 788        struct se_port *sep;
 789        ssize_t ret;
 790
 791        spin_lock(&lun->lun_sep_lock);
 792        sep = lun->lun_sep;
 793        if (!sep) {
 794                spin_unlock(&lun->lun_sep_lock);
 795                return -ENODEV;
 796        }
 797        /* FIXME: scsiPortBusyStatuses  */
 798        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
 799        spin_unlock(&lun->lun_sep_lock);
 800        return ret;
 801}
 802DEV_STAT_SCSI_PORT_ATTR_RO(busy_count);
 803
 804CONFIGFS_EATTR_OPS(target_stat_scsi_port, se_port_stat_grps, scsi_port_group);
 805
 806static struct configfs_attribute *target_stat_scsi_port_attrs[] = {
 807        &target_stat_scsi_port_inst.attr,
 808        &target_stat_scsi_port_dev.attr,
 809        &target_stat_scsi_port_indx.attr,
 810        &target_stat_scsi_port_role.attr,
 811        &target_stat_scsi_port_busy_count.attr,
 812        NULL,
 813};
 814
 815static struct configfs_item_operations target_stat_scsi_port_attrib_ops = {
 816        .show_attribute         = target_stat_scsi_port_attr_show,
 817        .store_attribute        = target_stat_scsi_port_attr_store,
 818};
 819
 820static struct config_item_type target_stat_scsi_port_cit = {
 821        .ct_item_ops            = &target_stat_scsi_port_attrib_ops,
 822        .ct_attrs               = target_stat_scsi_port_attrs,
 823        .ct_owner               = THIS_MODULE,
 824};
 825
 826/*
 827 * SCSI Target Port Table
 828 */
 829CONFIGFS_EATTR_STRUCT(target_stat_scsi_tgt_port, se_port_stat_grps);
 830#define DEV_STAT_SCSI_TGT_PORT_ATTR(_name, _mode)                       \
 831static struct target_stat_scsi_tgt_port_attribute                       \
 832                        target_stat_scsi_tgt_port_##_name =             \
 833        __CONFIGFS_EATTR(_name, _mode,                                  \
 834        target_stat_scsi_tgt_port_show_attr_##_name,                    \
 835        target_stat_scsi_tgt_port_store_attr_##_name);
 836
 837#define DEV_STAT_SCSI_TGT_PORT_ATTR_RO(_name)                           \
 838static struct target_stat_scsi_tgt_port_attribute                       \
 839                        target_stat_scsi_tgt_port_##_name =             \
 840        __CONFIGFS_EATTR_RO(_name,                                      \
 841        target_stat_scsi_tgt_port_show_attr_##_name);
 842
 843static ssize_t target_stat_scsi_tgt_port_show_attr_inst(
 844        struct se_port_stat_grps *pgrps, char *page)
 845{
 846        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 847        struct se_device *dev = lun->lun_se_dev;
 848        struct se_port *sep;
 849        struct se_hba *hba;
 850        ssize_t ret;
 851
 852        spin_lock(&lun->lun_sep_lock);
 853        sep = lun->lun_sep;
 854        if (!sep) {
 855                spin_unlock(&lun->lun_sep_lock);
 856                return -ENODEV;
 857        }
 858        hba = dev->se_hba;
 859        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
 860        spin_unlock(&lun->lun_sep_lock);
 861        return ret;
 862}
 863DEV_STAT_SCSI_TGT_PORT_ATTR_RO(inst);
 864
 865static ssize_t target_stat_scsi_tgt_port_show_attr_dev(
 866        struct se_port_stat_grps *pgrps, char *page)
 867{
 868        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 869        struct se_device *dev = lun->lun_se_dev;
 870        struct se_port *sep;
 871        ssize_t ret;
 872
 873        spin_lock(&lun->lun_sep_lock);
 874        sep = lun->lun_sep;
 875        if (!sep) {
 876                spin_unlock(&lun->lun_sep_lock);
 877                return -ENODEV;
 878        }
 879        ret = snprintf(page, PAGE_SIZE, "%u\n", dev->dev_index);
 880        spin_unlock(&lun->lun_sep_lock);
 881        return ret;
 882}
 883DEV_STAT_SCSI_TGT_PORT_ATTR_RO(dev);
 884
 885static ssize_t target_stat_scsi_tgt_port_show_attr_indx(
 886        struct se_port_stat_grps *pgrps, char *page)
 887{
 888        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 889        struct se_port *sep;
 890        ssize_t ret;
 891
 892        spin_lock(&lun->lun_sep_lock);
 893        sep = lun->lun_sep;
 894        if (!sep) {
 895                spin_unlock(&lun->lun_sep_lock);
 896                return -ENODEV;
 897        }
 898        ret = snprintf(page, PAGE_SIZE, "%u\n", sep->sep_index);
 899        spin_unlock(&lun->lun_sep_lock);
 900        return ret;
 901}
 902DEV_STAT_SCSI_TGT_PORT_ATTR_RO(indx);
 903
 904static ssize_t target_stat_scsi_tgt_port_show_attr_name(
 905        struct se_port_stat_grps *pgrps, char *page)
 906{
 907        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 908        struct se_port *sep;
 909        struct se_portal_group *tpg;
 910        ssize_t ret;
 911
 912        spin_lock(&lun->lun_sep_lock);
 913        sep = lun->lun_sep;
 914        if (!sep) {
 915                spin_unlock(&lun->lun_sep_lock);
 916                return -ENODEV;
 917        }
 918        tpg = sep->sep_tpg;
 919
 920        ret = snprintf(page, PAGE_SIZE, "%sPort#%u\n",
 921                tpg->se_tpg_tfo->get_fabric_name(), sep->sep_index);
 922        spin_unlock(&lun->lun_sep_lock);
 923        return ret;
 924}
 925DEV_STAT_SCSI_TGT_PORT_ATTR_RO(name);
 926
 927static ssize_t target_stat_scsi_tgt_port_show_attr_port_index(
 928        struct se_port_stat_grps *pgrps, char *page)
 929{
 930        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 931        struct se_port *sep;
 932        struct se_portal_group *tpg;
 933        ssize_t ret;
 934
 935        spin_lock(&lun->lun_sep_lock);
 936        sep = lun->lun_sep;
 937        if (!sep) {
 938                spin_unlock(&lun->lun_sep_lock);
 939                return -ENODEV;
 940        }
 941        tpg = sep->sep_tpg;
 942
 943        ret = snprintf(page, PAGE_SIZE, "%s%s%d\n",
 944                tpg->se_tpg_tfo->tpg_get_wwn(tpg), "+t+",
 945                tpg->se_tpg_tfo->tpg_get_tag(tpg));
 946        spin_unlock(&lun->lun_sep_lock);
 947        return ret;
 948}
 949DEV_STAT_SCSI_TGT_PORT_ATTR_RO(port_index);
 950
 951static ssize_t target_stat_scsi_tgt_port_show_attr_in_cmds(
 952        struct se_port_stat_grps *pgrps, char *page)
 953{
 954        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 955        struct se_port *sep;
 956        ssize_t ret;
 957
 958        spin_lock(&lun->lun_sep_lock);
 959        sep = lun->lun_sep;
 960        if (!sep) {
 961                spin_unlock(&lun->lun_sep_lock);
 962                return -ENODEV;
 963        }
 964
 965        ret = snprintf(page, PAGE_SIZE, "%llu\n", sep->sep_stats.cmd_pdus);
 966        spin_unlock(&lun->lun_sep_lock);
 967        return ret;
 968}
 969DEV_STAT_SCSI_TGT_PORT_ATTR_RO(in_cmds);
 970
 971static ssize_t target_stat_scsi_tgt_port_show_attr_write_mbytes(
 972        struct se_port_stat_grps *pgrps, char *page)
 973{
 974        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 975        struct se_port *sep;
 976        ssize_t ret;
 977
 978        spin_lock(&lun->lun_sep_lock);
 979        sep = lun->lun_sep;
 980        if (!sep) {
 981                spin_unlock(&lun->lun_sep_lock);
 982                return -ENODEV;
 983        }
 984
 985        ret = snprintf(page, PAGE_SIZE, "%u\n",
 986                        (u32)(sep->sep_stats.rx_data_octets >> 20));
 987        spin_unlock(&lun->lun_sep_lock);
 988        return ret;
 989}
 990DEV_STAT_SCSI_TGT_PORT_ATTR_RO(write_mbytes);
 991
 992static ssize_t target_stat_scsi_tgt_port_show_attr_read_mbytes(
 993        struct se_port_stat_grps *pgrps, char *page)
 994{
 995        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
 996        struct se_port *sep;
 997        ssize_t ret;
 998
 999        spin_lock(&lun->lun_sep_lock);
1000        sep = lun->lun_sep;
1001        if (!sep) {
1002                spin_unlock(&lun->lun_sep_lock);
1003                return -ENODEV;
1004        }
1005
1006        ret = snprintf(page, PAGE_SIZE, "%u\n",
1007                        (u32)(sep->sep_stats.tx_data_octets >> 20));
1008        spin_unlock(&lun->lun_sep_lock);
1009        return ret;
1010}
1011DEV_STAT_SCSI_TGT_PORT_ATTR_RO(read_mbytes);
1012
1013static ssize_t target_stat_scsi_tgt_port_show_attr_hs_in_cmds(
1014        struct se_port_stat_grps *pgrps, char *page)
1015{
1016        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1017        struct se_port *sep;
1018        ssize_t ret;
1019
1020        spin_lock(&lun->lun_sep_lock);
1021        sep = lun->lun_sep;
1022        if (!sep) {
1023                spin_unlock(&lun->lun_sep_lock);
1024                return -ENODEV;
1025        }
1026
1027        /* FIXME: scsiTgtPortHsInCommands */
1028        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1029        spin_unlock(&lun->lun_sep_lock);
1030        return ret;
1031}
1032DEV_STAT_SCSI_TGT_PORT_ATTR_RO(hs_in_cmds);
1033
1034CONFIGFS_EATTR_OPS(target_stat_scsi_tgt_port, se_port_stat_grps,
1035                scsi_tgt_port_group);
1036
1037static struct configfs_attribute *target_stat_scsi_tgt_port_attrs[] = {
1038        &target_stat_scsi_tgt_port_inst.attr,
1039        &target_stat_scsi_tgt_port_dev.attr,
1040        &target_stat_scsi_tgt_port_indx.attr,
1041        &target_stat_scsi_tgt_port_name.attr,
1042        &target_stat_scsi_tgt_port_port_index.attr,
1043        &target_stat_scsi_tgt_port_in_cmds.attr,
1044        &target_stat_scsi_tgt_port_write_mbytes.attr,
1045        &target_stat_scsi_tgt_port_read_mbytes.attr,
1046        &target_stat_scsi_tgt_port_hs_in_cmds.attr,
1047        NULL,
1048};
1049
1050static struct configfs_item_operations target_stat_scsi_tgt_port_attrib_ops = {
1051        .show_attribute         = target_stat_scsi_tgt_port_attr_show,
1052        .store_attribute        = target_stat_scsi_tgt_port_attr_store,
1053};
1054
1055static struct config_item_type target_stat_scsi_tgt_port_cit = {
1056        .ct_item_ops            = &target_stat_scsi_tgt_port_attrib_ops,
1057        .ct_attrs               = target_stat_scsi_tgt_port_attrs,
1058        .ct_owner               = THIS_MODULE,
1059};
1060
1061/*
1062 * SCSI Transport Table
1063o */
1064
1065CONFIGFS_EATTR_STRUCT(target_stat_scsi_transport, se_port_stat_grps);
1066#define DEV_STAT_SCSI_TRANSPORT_ATTR(_name, _mode)                      \
1067static struct target_stat_scsi_transport_attribute                      \
1068                        target_stat_scsi_transport_##_name =            \
1069        __CONFIGFS_EATTR(_name, _mode,                                  \
1070        target_stat_scsi_transport_show_attr_##_name,                   \
1071        target_stat_scsi_transport_store_attr_##_name);
1072
1073#define DEV_STAT_SCSI_TRANSPORT_ATTR_RO(_name)                          \
1074static struct target_stat_scsi_transport_attribute                      \
1075                        target_stat_scsi_transport_##_name =            \
1076        __CONFIGFS_EATTR_RO(_name,                                      \
1077        target_stat_scsi_transport_show_attr_##_name);
1078
1079static ssize_t target_stat_scsi_transport_show_attr_inst(
1080        struct se_port_stat_grps *pgrps, char *page)
1081{
1082        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1083        struct se_device *dev = lun->lun_se_dev;
1084        struct se_port *sep;
1085        struct se_hba *hba;
1086        ssize_t ret;
1087
1088        spin_lock(&lun->lun_sep_lock);
1089        sep = lun->lun_sep;
1090        if (!sep) {
1091                spin_unlock(&lun->lun_sep_lock);
1092                return -ENODEV;
1093        }
1094
1095        hba = dev->se_hba;
1096        ret = snprintf(page, PAGE_SIZE, "%u\n", hba->hba_index);
1097        spin_unlock(&lun->lun_sep_lock);
1098        return ret;
1099}
1100DEV_STAT_SCSI_TRANSPORT_ATTR_RO(inst);
1101
1102static ssize_t target_stat_scsi_transport_show_attr_device(
1103        struct se_port_stat_grps *pgrps, char *page)
1104{
1105        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1106        struct se_port *sep;
1107        struct se_portal_group *tpg;
1108        ssize_t ret;
1109
1110        spin_lock(&lun->lun_sep_lock);
1111        sep = lun->lun_sep;
1112        if (!sep) {
1113                spin_unlock(&lun->lun_sep_lock);
1114                return -ENODEV;
1115        }
1116        tpg = sep->sep_tpg;
1117        /* scsiTransportType */
1118        ret = snprintf(page, PAGE_SIZE, "scsiTransport%s\n",
1119                        tpg->se_tpg_tfo->get_fabric_name());
1120        spin_unlock(&lun->lun_sep_lock);
1121        return ret;
1122}
1123DEV_STAT_SCSI_TRANSPORT_ATTR_RO(device);
1124
1125static ssize_t target_stat_scsi_transport_show_attr_indx(
1126        struct se_port_stat_grps *pgrps, char *page)
1127{
1128        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1129        struct se_port *sep;
1130        struct se_portal_group *tpg;
1131        ssize_t ret;
1132
1133        spin_lock(&lun->lun_sep_lock);
1134        sep = lun->lun_sep;
1135        if (!sep) {
1136                spin_unlock(&lun->lun_sep_lock);
1137                return -ENODEV;
1138        }
1139        tpg = sep->sep_tpg;
1140        ret = snprintf(page, PAGE_SIZE, "%u\n",
1141                        tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1142        spin_unlock(&lun->lun_sep_lock);
1143        return ret;
1144}
1145DEV_STAT_SCSI_TRANSPORT_ATTR_RO(indx);
1146
1147static ssize_t target_stat_scsi_transport_show_attr_dev_name(
1148        struct se_port_stat_grps *pgrps, char *page)
1149{
1150        struct se_lun *lun = container_of(pgrps, struct se_lun, port_stat_grps);
1151        struct se_device *dev = lun->lun_se_dev;
1152        struct se_port *sep;
1153        struct se_portal_group *tpg;
1154        struct t10_wwn *wwn;
1155        ssize_t ret;
1156
1157        spin_lock(&lun->lun_sep_lock);
1158        sep = lun->lun_sep;
1159        if (!sep) {
1160                spin_unlock(&lun->lun_sep_lock);
1161                return -ENODEV;
1162        }
1163        tpg = sep->sep_tpg;
1164        wwn = &dev->se_sub_dev->t10_wwn;
1165        /* scsiTransportDevName */
1166        ret = snprintf(page, PAGE_SIZE, "%s+%s\n",
1167                        tpg->se_tpg_tfo->tpg_get_wwn(tpg),
1168                        (strlen(wwn->unit_serial)) ? wwn->unit_serial :
1169                        wwn->vendor);
1170        spin_unlock(&lun->lun_sep_lock);
1171        return ret;
1172}
1173DEV_STAT_SCSI_TRANSPORT_ATTR_RO(dev_name);
1174
1175CONFIGFS_EATTR_OPS(target_stat_scsi_transport, se_port_stat_grps,
1176                scsi_transport_group);
1177
1178static struct configfs_attribute *target_stat_scsi_transport_attrs[] = {
1179        &target_stat_scsi_transport_inst.attr,
1180        &target_stat_scsi_transport_device.attr,
1181        &target_stat_scsi_transport_indx.attr,
1182        &target_stat_scsi_transport_dev_name.attr,
1183        NULL,
1184};
1185
1186static struct configfs_item_operations target_stat_scsi_transport_attrib_ops = {
1187        .show_attribute         = target_stat_scsi_transport_attr_show,
1188        .store_attribute        = target_stat_scsi_transport_attr_store,
1189};
1190
1191static struct config_item_type target_stat_scsi_transport_cit = {
1192        .ct_item_ops            = &target_stat_scsi_transport_attrib_ops,
1193        .ct_attrs               = target_stat_scsi_transport_attrs,
1194        .ct_owner               = THIS_MODULE,
1195};
1196
1197/*
1198 * Called from target_core_fabric_configfs.c:target_fabric_make_lun() to setup
1199 * the target port statistics groups + configfs CITs located in target_core_stat.c
1200 */
1201void target_stat_setup_port_default_groups(struct se_lun *lun)
1202{
1203        struct config_group *port_stat_grp = &lun->port_stat_grps.stat_group;
1204
1205        config_group_init_type_name(&lun->port_stat_grps.scsi_port_group,
1206                        "scsi_port", &target_stat_scsi_port_cit);
1207        config_group_init_type_name(&lun->port_stat_grps.scsi_tgt_port_group,
1208                        "scsi_tgt_port", &target_stat_scsi_tgt_port_cit);
1209        config_group_init_type_name(&lun->port_stat_grps.scsi_transport_group,
1210                        "scsi_transport", &target_stat_scsi_transport_cit);
1211
1212        port_stat_grp->default_groups[0] = &lun->port_stat_grps.scsi_port_group;
1213        port_stat_grp->default_groups[1] = &lun->port_stat_grps.scsi_tgt_port_group;
1214        port_stat_grp->default_groups[2] = &lun->port_stat_grps.scsi_transport_group;
1215        port_stat_grp->default_groups[3] = NULL;
1216}
1217
1218/*
1219 * SCSI Authorized Initiator Table
1220 */
1221
1222CONFIGFS_EATTR_STRUCT(target_stat_scsi_auth_intr, se_ml_stat_grps);
1223#define DEV_STAT_SCSI_AUTH_INTR_ATTR(_name, _mode)                      \
1224static struct target_stat_scsi_auth_intr_attribute                      \
1225                        target_stat_scsi_auth_intr_##_name =            \
1226        __CONFIGFS_EATTR(_name, _mode,                                  \
1227        target_stat_scsi_auth_intr_show_attr_##_name,                   \
1228        target_stat_scsi_auth_intr_store_attr_##_name);
1229
1230#define DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(_name)                          \
1231static struct target_stat_scsi_auth_intr_attribute                      \
1232                        target_stat_scsi_auth_intr_##_name =            \
1233        __CONFIGFS_EATTR_RO(_name,                                      \
1234        target_stat_scsi_auth_intr_show_attr_##_name);
1235
1236static ssize_t target_stat_scsi_auth_intr_show_attr_inst(
1237        struct se_ml_stat_grps *lgrps, char *page)
1238{
1239        struct se_lun_acl *lacl = container_of(lgrps,
1240                        struct se_lun_acl, ml_stat_grps);
1241        struct se_node_acl *nacl = lacl->se_lun_nacl;
1242        struct se_dev_entry *deve;
1243        struct se_portal_group *tpg;
1244        ssize_t ret;
1245
1246        spin_lock_irq(&nacl->device_list_lock);
1247        deve = nacl->device_list[lacl->mapped_lun];
1248        if (!deve->se_lun || !deve->se_lun_acl) {
1249                spin_unlock_irq(&nacl->device_list_lock);
1250                return -ENODEV;
1251        }
1252        tpg = nacl->se_tpg;
1253        /* scsiInstIndex */
1254        ret = snprintf(page, PAGE_SIZE, "%u\n",
1255                        tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1256        spin_unlock_irq(&nacl->device_list_lock);
1257        return ret;
1258}
1259DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(inst);
1260
1261static ssize_t target_stat_scsi_auth_intr_show_attr_dev(
1262        struct se_ml_stat_grps *lgrps, char *page)
1263{
1264        struct se_lun_acl *lacl = container_of(lgrps,
1265                        struct se_lun_acl, ml_stat_grps);
1266        struct se_node_acl *nacl = lacl->se_lun_nacl;
1267        struct se_dev_entry *deve;
1268        struct se_lun *lun;
1269        ssize_t ret;
1270
1271        spin_lock_irq(&nacl->device_list_lock);
1272        deve = nacl->device_list[lacl->mapped_lun];
1273        if (!deve->se_lun || !deve->se_lun_acl) {
1274                spin_unlock_irq(&nacl->device_list_lock);
1275                return -ENODEV;
1276        }
1277        lun = deve->se_lun;
1278        /* scsiDeviceIndex */
1279        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1280        spin_unlock_irq(&nacl->device_list_lock);
1281        return ret;
1282}
1283DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev);
1284
1285static ssize_t target_stat_scsi_auth_intr_show_attr_port(
1286        struct se_ml_stat_grps *lgrps, char *page)
1287{
1288        struct se_lun_acl *lacl = container_of(lgrps,
1289                        struct se_lun_acl, ml_stat_grps);
1290        struct se_node_acl *nacl = lacl->se_lun_nacl;
1291        struct se_dev_entry *deve;
1292        struct se_portal_group *tpg;
1293        ssize_t ret;
1294
1295        spin_lock_irq(&nacl->device_list_lock);
1296        deve = nacl->device_list[lacl->mapped_lun];
1297        if (!deve->se_lun || !deve->se_lun_acl) {
1298                spin_unlock_irq(&nacl->device_list_lock);
1299                return -ENODEV;
1300        }
1301        tpg = nacl->se_tpg;
1302        /* scsiAuthIntrTgtPortIndex */
1303        ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1304        spin_unlock_irq(&nacl->device_list_lock);
1305        return ret;
1306}
1307DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(port);
1308
1309static ssize_t target_stat_scsi_auth_intr_show_attr_indx(
1310        struct se_ml_stat_grps *lgrps, char *page)
1311{
1312        struct se_lun_acl *lacl = container_of(lgrps,
1313                        struct se_lun_acl, ml_stat_grps);
1314        struct se_node_acl *nacl = lacl->se_lun_nacl;
1315        struct se_dev_entry *deve;
1316        ssize_t ret;
1317
1318        spin_lock_irq(&nacl->device_list_lock);
1319        deve = nacl->device_list[lacl->mapped_lun];
1320        if (!deve->se_lun || !deve->se_lun_acl) {
1321                spin_unlock_irq(&nacl->device_list_lock);
1322                return -ENODEV;
1323        }
1324        /* scsiAuthIntrIndex */
1325        ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1326        spin_unlock_irq(&nacl->device_list_lock);
1327        return ret;
1328}
1329DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(indx);
1330
1331static ssize_t target_stat_scsi_auth_intr_show_attr_dev_or_port(
1332        struct se_ml_stat_grps *lgrps, char *page)
1333{
1334        struct se_lun_acl *lacl = container_of(lgrps,
1335                        struct se_lun_acl, ml_stat_grps);
1336        struct se_node_acl *nacl = lacl->se_lun_nacl;
1337        struct se_dev_entry *deve;
1338        ssize_t ret;
1339
1340        spin_lock_irq(&nacl->device_list_lock);
1341        deve = nacl->device_list[lacl->mapped_lun];
1342        if (!deve->se_lun || !deve->se_lun_acl) {
1343                spin_unlock_irq(&nacl->device_list_lock);
1344                return -ENODEV;
1345        }
1346        /* scsiAuthIntrDevOrPort */
1347        ret = snprintf(page, PAGE_SIZE, "%u\n", 1);
1348        spin_unlock_irq(&nacl->device_list_lock);
1349        return ret;
1350}
1351DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(dev_or_port);
1352
1353static ssize_t target_stat_scsi_auth_intr_show_attr_intr_name(
1354        struct se_ml_stat_grps *lgrps, char *page)
1355{
1356        struct se_lun_acl *lacl = container_of(lgrps,
1357                        struct se_lun_acl, ml_stat_grps);
1358        struct se_node_acl *nacl = lacl->se_lun_nacl;
1359        struct se_dev_entry *deve;
1360        ssize_t ret;
1361
1362        spin_lock_irq(&nacl->device_list_lock);
1363        deve = nacl->device_list[lacl->mapped_lun];
1364        if (!deve->se_lun || !deve->se_lun_acl) {
1365                spin_unlock_irq(&nacl->device_list_lock);
1366                return -ENODEV;
1367        }
1368        /* scsiAuthIntrName */
1369        ret = snprintf(page, PAGE_SIZE, "%s\n", nacl->initiatorname);
1370        spin_unlock_irq(&nacl->device_list_lock);
1371        return ret;
1372}
1373DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(intr_name);
1374
1375static ssize_t target_stat_scsi_auth_intr_show_attr_map_indx(
1376        struct se_ml_stat_grps *lgrps, char *page)
1377{
1378        struct se_lun_acl *lacl = container_of(lgrps,
1379                        struct se_lun_acl, ml_stat_grps);
1380        struct se_node_acl *nacl = lacl->se_lun_nacl;
1381        struct se_dev_entry *deve;
1382        ssize_t ret;
1383
1384        spin_lock_irq(&nacl->device_list_lock);
1385        deve = nacl->device_list[lacl->mapped_lun];
1386        if (!deve->se_lun || !deve->se_lun_acl) {
1387                spin_unlock_irq(&nacl->device_list_lock);
1388                return -ENODEV;
1389        }
1390        /* FIXME: scsiAuthIntrLunMapIndex */
1391        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1392        spin_unlock_irq(&nacl->device_list_lock);
1393        return ret;
1394}
1395DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(map_indx);
1396
1397static ssize_t target_stat_scsi_auth_intr_show_attr_att_count(
1398        struct se_ml_stat_grps *lgrps, char *page)
1399{
1400        struct se_lun_acl *lacl = container_of(lgrps,
1401                        struct se_lun_acl, ml_stat_grps);
1402        struct se_node_acl *nacl = lacl->se_lun_nacl;
1403        struct se_dev_entry *deve;
1404        ssize_t ret;
1405
1406        spin_lock_irq(&nacl->device_list_lock);
1407        deve = nacl->device_list[lacl->mapped_lun];
1408        if (!deve->se_lun || !deve->se_lun_acl) {
1409                spin_unlock_irq(&nacl->device_list_lock);
1410                return -ENODEV;
1411        }
1412        /* scsiAuthIntrAttachedTimes */
1413        ret = snprintf(page, PAGE_SIZE, "%u\n", deve->attach_count);
1414        spin_unlock_irq(&nacl->device_list_lock);
1415        return ret;
1416}
1417DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(att_count);
1418
1419static ssize_t target_stat_scsi_auth_intr_show_attr_num_cmds(
1420        struct se_ml_stat_grps *lgrps, char *page)
1421{
1422        struct se_lun_acl *lacl = container_of(lgrps,
1423                        struct se_lun_acl, ml_stat_grps);
1424        struct se_node_acl *nacl = lacl->se_lun_nacl;
1425        struct se_dev_entry *deve;
1426        ssize_t ret;
1427
1428        spin_lock_irq(&nacl->device_list_lock);
1429        deve = nacl->device_list[lacl->mapped_lun];
1430        if (!deve->se_lun || !deve->se_lun_acl) {
1431                spin_unlock_irq(&nacl->device_list_lock);
1432                return -ENODEV;
1433        }
1434        /* scsiAuthIntrOutCommands */
1435        ret = snprintf(page, PAGE_SIZE, "%u\n", deve->total_cmds);
1436        spin_unlock_irq(&nacl->device_list_lock);
1437        return ret;
1438}
1439DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(num_cmds);
1440
1441static ssize_t target_stat_scsi_auth_intr_show_attr_read_mbytes(
1442        struct se_ml_stat_grps *lgrps, char *page)
1443{
1444        struct se_lun_acl *lacl = container_of(lgrps,
1445                        struct se_lun_acl, ml_stat_grps);
1446        struct se_node_acl *nacl = lacl->se_lun_nacl;
1447        struct se_dev_entry *deve;
1448        ssize_t ret;
1449
1450        spin_lock_irq(&nacl->device_list_lock);
1451        deve = nacl->device_list[lacl->mapped_lun];
1452        if (!deve->se_lun || !deve->se_lun_acl) {
1453                spin_unlock_irq(&nacl->device_list_lock);
1454                return -ENODEV;
1455        }
1456        /* scsiAuthIntrReadMegaBytes */
1457        ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->read_bytes >> 20));
1458        spin_unlock_irq(&nacl->device_list_lock);
1459        return ret;
1460}
1461DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(read_mbytes);
1462
1463static ssize_t target_stat_scsi_auth_intr_show_attr_write_mbytes(
1464        struct se_ml_stat_grps *lgrps, char *page)
1465{
1466        struct se_lun_acl *lacl = container_of(lgrps,
1467                        struct se_lun_acl, ml_stat_grps);
1468        struct se_node_acl *nacl = lacl->se_lun_nacl;
1469        struct se_dev_entry *deve;
1470        ssize_t ret;
1471
1472        spin_lock_irq(&nacl->device_list_lock);
1473        deve = nacl->device_list[lacl->mapped_lun];
1474        if (!deve->se_lun || !deve->se_lun_acl) {
1475                spin_unlock_irq(&nacl->device_list_lock);
1476                return -ENODEV;
1477        }
1478        /* scsiAuthIntrWrittenMegaBytes */
1479        ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(deve->write_bytes >> 20));
1480        spin_unlock_irq(&nacl->device_list_lock);
1481        return ret;
1482}
1483DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(write_mbytes);
1484
1485static ssize_t target_stat_scsi_auth_intr_show_attr_hs_num_cmds(
1486        struct se_ml_stat_grps *lgrps, char *page)
1487{
1488        struct se_lun_acl *lacl = container_of(lgrps,
1489                        struct se_lun_acl, ml_stat_grps);
1490        struct se_node_acl *nacl = lacl->se_lun_nacl;
1491        struct se_dev_entry *deve;
1492        ssize_t ret;
1493
1494        spin_lock_irq(&nacl->device_list_lock);
1495        deve = nacl->device_list[lacl->mapped_lun];
1496        if (!deve->se_lun || !deve->se_lun_acl) {
1497                spin_unlock_irq(&nacl->device_list_lock);
1498                return -ENODEV;
1499        }
1500        /* FIXME: scsiAuthIntrHSOutCommands */
1501        ret = snprintf(page, PAGE_SIZE, "%u\n", 0);
1502        spin_unlock_irq(&nacl->device_list_lock);
1503        return ret;
1504}
1505DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(hs_num_cmds);
1506
1507static ssize_t target_stat_scsi_auth_intr_show_attr_creation_time(
1508        struct se_ml_stat_grps *lgrps, char *page)
1509{
1510        struct se_lun_acl *lacl = container_of(lgrps,
1511                        struct se_lun_acl, ml_stat_grps);
1512        struct se_node_acl *nacl = lacl->se_lun_nacl;
1513        struct se_dev_entry *deve;
1514        ssize_t ret;
1515
1516        spin_lock_irq(&nacl->device_list_lock);
1517        deve = nacl->device_list[lacl->mapped_lun];
1518        if (!deve->se_lun || !deve->se_lun_acl) {
1519                spin_unlock_irq(&nacl->device_list_lock);
1520                return -ENODEV;
1521        }
1522        /* scsiAuthIntrLastCreation */
1523        ret = snprintf(page, PAGE_SIZE, "%u\n", (u32)(((u32)deve->creation_time -
1524                                INITIAL_JIFFIES) * 100 / HZ));
1525        spin_unlock_irq(&nacl->device_list_lock);
1526        return ret;
1527}
1528DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(creation_time);
1529
1530static ssize_t target_stat_scsi_auth_intr_show_attr_row_status(
1531        struct se_ml_stat_grps *lgrps, char *page)
1532{
1533        struct se_lun_acl *lacl = container_of(lgrps,
1534                        struct se_lun_acl, ml_stat_grps);
1535        struct se_node_acl *nacl = lacl->se_lun_nacl;
1536        struct se_dev_entry *deve;
1537        ssize_t ret;
1538
1539        spin_lock_irq(&nacl->device_list_lock);
1540        deve = nacl->device_list[lacl->mapped_lun];
1541        if (!deve->se_lun || !deve->se_lun_acl) {
1542                spin_unlock_irq(&nacl->device_list_lock);
1543                return -ENODEV;
1544        }
1545        /* FIXME: scsiAuthIntrRowStatus */
1546        ret = snprintf(page, PAGE_SIZE, "Ready\n");
1547        spin_unlock_irq(&nacl->device_list_lock);
1548        return ret;
1549}
1550DEV_STAT_SCSI_AUTH_INTR_ATTR_RO(row_status);
1551
1552CONFIGFS_EATTR_OPS(target_stat_scsi_auth_intr, se_ml_stat_grps,
1553                scsi_auth_intr_group);
1554
1555static struct configfs_attribute *target_stat_scsi_auth_intr_attrs[] = {
1556        &target_stat_scsi_auth_intr_inst.attr,
1557        &target_stat_scsi_auth_intr_dev.attr,
1558        &target_stat_scsi_auth_intr_port.attr,
1559        &target_stat_scsi_auth_intr_indx.attr,
1560        &target_stat_scsi_auth_intr_dev_or_port.attr,
1561        &target_stat_scsi_auth_intr_intr_name.attr,
1562        &target_stat_scsi_auth_intr_map_indx.attr,
1563        &target_stat_scsi_auth_intr_att_count.attr,
1564        &target_stat_scsi_auth_intr_num_cmds.attr,
1565        &target_stat_scsi_auth_intr_read_mbytes.attr,
1566        &target_stat_scsi_auth_intr_write_mbytes.attr,
1567        &target_stat_scsi_auth_intr_hs_num_cmds.attr,
1568        &target_stat_scsi_auth_intr_creation_time.attr,
1569        &target_stat_scsi_auth_intr_row_status.attr,
1570        NULL,
1571};
1572
1573static struct configfs_item_operations target_stat_scsi_auth_intr_attrib_ops = {
1574        .show_attribute         = target_stat_scsi_auth_intr_attr_show,
1575        .store_attribute        = target_stat_scsi_auth_intr_attr_store,
1576};
1577
1578static struct config_item_type target_stat_scsi_auth_intr_cit = {
1579        .ct_item_ops            = &target_stat_scsi_auth_intr_attrib_ops,
1580        .ct_attrs               = target_stat_scsi_auth_intr_attrs,
1581        .ct_owner               = THIS_MODULE,
1582};
1583
1584/*
1585 * SCSI Attached Initiator Port Table
1586 */
1587
1588CONFIGFS_EATTR_STRUCT(target_stat_scsi_att_intr_port, se_ml_stat_grps);
1589#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR(_name, _mode)                 \
1590static struct target_stat_scsi_att_intr_port_attribute                  \
1591                target_stat_scsi_att_intr_port_##_name =                \
1592        __CONFIGFS_EATTR(_name, _mode,                                  \
1593        target_stat_scsi_att_intr_port_show_attr_##_name,               \
1594        target_stat_scsi_att_intr_port_store_attr_##_name);
1595
1596#define DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(_name)                     \
1597static struct target_stat_scsi_att_intr_port_attribute                  \
1598                target_stat_scsi_att_intr_port_##_name =                \
1599        __CONFIGFS_EATTR_RO(_name,                                      \
1600        target_stat_scsi_att_intr_port_show_attr_##_name);
1601
1602static ssize_t target_stat_scsi_att_intr_port_show_attr_inst(
1603        struct se_ml_stat_grps *lgrps, char *page)
1604{
1605        struct se_lun_acl *lacl = container_of(lgrps,
1606                        struct se_lun_acl, ml_stat_grps);
1607        struct se_node_acl *nacl = lacl->se_lun_nacl;
1608        struct se_dev_entry *deve;
1609        struct se_portal_group *tpg;
1610        ssize_t ret;
1611
1612        spin_lock_irq(&nacl->device_list_lock);
1613        deve = nacl->device_list[lacl->mapped_lun];
1614        if (!deve->se_lun || !deve->se_lun_acl) {
1615                spin_unlock_irq(&nacl->device_list_lock);
1616                return -ENODEV;
1617        }
1618        tpg = nacl->se_tpg;
1619        /* scsiInstIndex */
1620        ret = snprintf(page, PAGE_SIZE, "%u\n",
1621                        tpg->se_tpg_tfo->tpg_get_inst_index(tpg));
1622        spin_unlock_irq(&nacl->device_list_lock);
1623        return ret;
1624}
1625DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(inst);
1626
1627static ssize_t target_stat_scsi_att_intr_port_show_attr_dev(
1628        struct se_ml_stat_grps *lgrps, char *page)
1629{
1630        struct se_lun_acl *lacl = container_of(lgrps,
1631                        struct se_lun_acl, ml_stat_grps);
1632        struct se_node_acl *nacl = lacl->se_lun_nacl;
1633        struct se_dev_entry *deve;
1634        struct se_lun *lun;
1635        ssize_t ret;
1636
1637        spin_lock_irq(&nacl->device_list_lock);
1638        deve = nacl->device_list[lacl->mapped_lun];
1639        if (!deve->se_lun || !deve->se_lun_acl) {
1640                spin_unlock_irq(&nacl->device_list_lock);
1641                return -ENODEV;
1642        }
1643        lun = deve->se_lun;
1644        /* scsiDeviceIndex */
1645        ret = snprintf(page, PAGE_SIZE, "%u\n", lun->lun_se_dev->dev_index);
1646        spin_unlock_irq(&nacl->device_list_lock);
1647        return ret;
1648}
1649DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(dev);
1650
1651static ssize_t target_stat_scsi_att_intr_port_show_attr_port(
1652        struct se_ml_stat_grps *lgrps, char *page)
1653{
1654        struct se_lun_acl *lacl = container_of(lgrps,
1655                        struct se_lun_acl, ml_stat_grps);
1656        struct se_node_acl *nacl = lacl->se_lun_nacl;
1657        struct se_dev_entry *deve;
1658        struct se_portal_group *tpg;
1659        ssize_t ret;
1660
1661        spin_lock_irq(&nacl->device_list_lock);
1662        deve = nacl->device_list[lacl->mapped_lun];
1663        if (!deve->se_lun || !deve->se_lun_acl) {
1664                spin_unlock_irq(&nacl->device_list_lock);
1665                return -ENODEV;
1666        }
1667        tpg = nacl->se_tpg;
1668        /* scsiPortIndex */
1669        ret = snprintf(page, PAGE_SIZE, "%u\n", tpg->se_tpg_tfo->tpg_get_tag(tpg));
1670        spin_unlock_irq(&nacl->device_list_lock);
1671        return ret;
1672}
1673DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port);
1674
1675static ssize_t target_stat_scsi_att_intr_port_show_attr_indx(
1676        struct se_ml_stat_grps *lgrps, char *page)
1677{
1678        struct se_lun_acl *lacl = container_of(lgrps,
1679                        struct se_lun_acl, ml_stat_grps);
1680        struct se_node_acl *nacl = lacl->se_lun_nacl;
1681        struct se_session *se_sess;
1682        struct se_portal_group *tpg;
1683        ssize_t ret;
1684
1685        spin_lock_irq(&nacl->nacl_sess_lock);
1686        se_sess = nacl->nacl_sess;
1687        if (!se_sess) {
1688                spin_unlock_irq(&nacl->nacl_sess_lock);
1689                return -ENODEV;
1690        }
1691
1692        tpg = nacl->se_tpg;
1693        /* scsiAttIntrPortIndex */
1694        ret = snprintf(page, PAGE_SIZE, "%u\n",
1695                        tpg->se_tpg_tfo->sess_get_index(se_sess));
1696        spin_unlock_irq(&nacl->nacl_sess_lock);
1697        return ret;
1698}
1699DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(indx);
1700
1701static ssize_t target_stat_scsi_att_intr_port_show_attr_port_auth_indx(
1702        struct se_ml_stat_grps *lgrps, char *page)
1703{
1704        struct se_lun_acl *lacl = container_of(lgrps,
1705                        struct se_lun_acl, ml_stat_grps);
1706        struct se_node_acl *nacl = lacl->se_lun_nacl;
1707        struct se_dev_entry *deve;
1708        ssize_t ret;
1709
1710        spin_lock_irq(&nacl->device_list_lock);
1711        deve = nacl->device_list[lacl->mapped_lun];
1712        if (!deve->se_lun || !deve->se_lun_acl) {
1713                spin_unlock_irq(&nacl->device_list_lock);
1714                return -ENODEV;
1715        }
1716        /* scsiAttIntrPortAuthIntrIdx */
1717        ret = snprintf(page, PAGE_SIZE, "%u\n", nacl->acl_index);
1718        spin_unlock_irq(&nacl->device_list_lock);
1719        return ret;
1720}
1721DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_auth_indx);
1722
1723static ssize_t target_stat_scsi_att_intr_port_show_attr_port_ident(
1724        struct se_ml_stat_grps *lgrps, char *page)
1725{
1726        struct se_lun_acl *lacl = container_of(lgrps,
1727                        struct se_lun_acl, ml_stat_grps);
1728        struct se_node_acl *nacl = lacl->se_lun_nacl;
1729        struct se_session *se_sess;
1730        struct se_portal_group *tpg;
1731        ssize_t ret;
1732        unsigned char buf[64];
1733
1734        spin_lock_irq(&nacl->nacl_sess_lock);
1735        se_sess = nacl->nacl_sess;
1736        if (!se_sess) {
1737                spin_unlock_irq(&nacl->nacl_sess_lock);
1738                return -ENODEV;
1739        }
1740
1741        tpg = nacl->se_tpg;
1742        /* scsiAttIntrPortName+scsiAttIntrPortIdentifier */
1743        memset(buf, 0, 64);
1744        if (tpg->se_tpg_tfo->sess_get_initiator_sid != NULL)
1745                tpg->se_tpg_tfo->sess_get_initiator_sid(se_sess, buf, 64);
1746
1747        ret = snprintf(page, PAGE_SIZE, "%s+i+%s\n", nacl->initiatorname, buf);
1748        spin_unlock_irq(&nacl->nacl_sess_lock);
1749        return ret;
1750}
1751DEV_STAT_SCSI_ATTR_INTR_PORT_ATTR_RO(port_ident);
1752
1753CONFIGFS_EATTR_OPS(target_stat_scsi_att_intr_port, se_ml_stat_grps,
1754                scsi_att_intr_port_group);
1755
1756static struct configfs_attribute *target_stat_scsi_ath_intr_port_attrs[] = {
1757        &target_stat_scsi_att_intr_port_inst.attr,
1758        &target_stat_scsi_att_intr_port_dev.attr,
1759        &target_stat_scsi_att_intr_port_port.attr,
1760        &target_stat_scsi_att_intr_port_indx.attr,
1761        &target_stat_scsi_att_intr_port_port_auth_indx.attr,
1762        &target_stat_scsi_att_intr_port_port_ident.attr,
1763        NULL,
1764};
1765
1766static struct configfs_item_operations target_stat_scsi_att_intr_port_attrib_ops = {
1767        .show_attribute         = target_stat_scsi_att_intr_port_attr_show,
1768        .store_attribute        = target_stat_scsi_att_intr_port_attr_store,
1769};
1770
1771static struct config_item_type target_stat_scsi_att_intr_port_cit = {
1772        .ct_item_ops            = &target_stat_scsi_att_intr_port_attrib_ops,
1773        .ct_attrs               = target_stat_scsi_ath_intr_port_attrs,
1774        .ct_owner               = THIS_MODULE,
1775};
1776
1777/*
1778 * Called from target_core_fabric_configfs.c:target_fabric_make_mappedlun() to setup
1779 * the target MappedLUN statistics groups + configfs CITs located in target_core_stat.c
1780 */
1781void target_stat_setup_mappedlun_default_groups(struct se_lun_acl *lacl)
1782{
1783        struct config_group *ml_stat_grp = &lacl->ml_stat_grps.stat_group;
1784
1785        config_group_init_type_name(&lacl->ml_stat_grps.scsi_auth_intr_group,
1786                        "scsi_auth_intr", &target_stat_scsi_auth_intr_cit);
1787        config_group_init_type_name(&lacl->ml_stat_grps.scsi_att_intr_port_group,
1788                        "scsi_att_intr_port", &target_stat_scsi_att_intr_port_cit);
1789
1790        ml_stat_grp->default_groups[0] = &lacl->ml_stat_grps.scsi_auth_intr_group;
1791        ml_stat_grp->default_groups[1] = &lacl->ml_stat_grps.scsi_att_intr_port_group;
1792        ml_stat_grp->default_groups[2] = NULL;
1793}
1794
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.