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