1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*******************************************************************************
3 * Filename: target_core_configfs.c
4 *
5 * This file contains ConfigFS logic for the Generic Target Engine project.
6 *
7 * (c) Copyright 2008-2013 Datera, Inc.
8 *
9 * Nicholas A. Bellinger <nab@kernel.org>
10 *
11 * based on configfs Copyright (C) 2005 Oracle. All rights reserved.
12 *
13 ****************************************************************************/
14
15 #include <linux/kstrtox.h>
16 #include <linux/module.h>
17 #include <linux/moduleparam.h>
18 #include <generated/utsrelease.h>
19 #include <linux/utsname.h>
20 #include <linux/init.h>
21 #include <linux/fs.h>
22 #include <linux/namei.h>
23 #include <linux/slab.h>
24 #include <linux/types.h>
25 #include <linux/delay.h>
26 #include <linux/unistd.h>
27 #include <linux/string.h>
28 #include <linux/parser.h>
29 #include <linux/syscalls.h>
30 #include <linux/configfs.h>
31 #include <linux/spinlock.h>
32
33 #include <target/target_core_base.h>
34 #include <target/target_core_backend.h>
35 #include <target/target_core_fabric.h>
36
37 #include "target_core_internal.h"
38 #include "target_core_alua.h"
39 #include "target_core_pr.h"
40 #include "target_core_rd.h"
41 #include "target_core_xcopy.h"
42
43 #define TB_CIT_SETUP(_name, _item_ops, _group_ops, _attrs) \
44 static void target_core_setup_##_name##_cit(struct target_backend *tb) \
45 { \
46 struct config_item_type *cit = &tb->tb_##_name##_cit; \
47 \
48 cit->ct_item_ops = _item_ops; \
49 cit->ct_group_ops = _group_ops; \
50 cit->ct_attrs = _attrs; \
51 cit->ct_owner = tb->ops->owner; \
52 pr_debug("Setup generic %s\n", __stringify(_name)); \
53 }
54
55 #define TB_CIT_SETUP_DRV(_name, _item_ops, _group_ops) \
56 static void target_core_setup_##_name##_cit(struct target_backend *tb) \
57 { \
58 struct config_item_type *cit = &tb->tb_##_name##_cit; \
59 \
60 cit->ct_item_ops = _item_ops; \
61 cit->ct_group_ops = _group_ops; \
62 cit->ct_attrs = tb->ops->tb_##_name##_attrs; \
63 cit->ct_owner = tb->ops->owner; \
64 pr_debug("Setup generic %s\n", __stringify(_name)); \
65 }
66
67 extern struct t10_alua_lu_gp *default_lu_gp;
68
69 static LIST_HEAD(g_tf_list);
70 static DEFINE_MUTEX(g_tf_lock);
71
72 static struct config_group target_core_hbagroup;
73 static struct config_group alua_group;
74 static struct config_group alua_lu_gps_group;
75
76 static unsigned int target_devices;
77 static DEFINE_MUTEX(target_devices_lock);
78
79 static inline struct se_hba *
item_to_hba(struct config_item * item)80 item_to_hba(struct config_item *item)
81 {
82 return container_of(to_config_group(item), struct se_hba, hba_group);
83 }
84
85 /*
86 * Attributes for /sys/kernel/config/target/
87 */
target_core_item_version_show(struct config_item * item,char * page)88 static ssize_t target_core_item_version_show(struct config_item *item,
89 char *page)
90 {
91 return sprintf(page, "Target Engine Core ConfigFS Infrastructure %s"
92 " on %s/%s on "UTS_RELEASE"\n", TARGET_CORE_VERSION,
93 utsname()->sysname, utsname()->machine);
94 }
95
96 CONFIGFS_ATTR_RO(target_core_item_, version);
97
98 char db_root[DB_ROOT_LEN] = DB_ROOT_DEFAULT;
99 static char db_root_stage[DB_ROOT_LEN];
100
target_core_item_dbroot_show(struct config_item * item,char * page)101 static ssize_t target_core_item_dbroot_show(struct config_item *item,
102 char *page)
103 {
104 return sprintf(page, "%s\n", db_root);
105 }
106
target_core_item_dbroot_store(struct config_item * item,const char * page,size_t count)107 static ssize_t target_core_item_dbroot_store(struct config_item *item,
108 const char *page, size_t count)
109 {
110 ssize_t read_bytes;
111 struct file *fp;
112 ssize_t r = -EINVAL;
113
114 mutex_lock(&target_devices_lock);
115 if (target_devices) {
116 pr_err("db_root: cannot be changed because it's in use\n");
117 goto unlock;
118 }
119
120 if (count > (DB_ROOT_LEN - 1)) {
121 pr_err("db_root: count %d exceeds DB_ROOT_LEN-1: %u\n",
122 (int)count, DB_ROOT_LEN - 1);
123 goto unlock;
124 }
125
126 read_bytes = snprintf(db_root_stage, DB_ROOT_LEN, "%s", page);
127 if (!read_bytes)
128 goto unlock;
129
130 if (db_root_stage[read_bytes - 1] == '\n')
131 db_root_stage[read_bytes - 1] = '\0';
132
133 /* validate new db root before accepting it */
134 fp = filp_open(db_root_stage, O_RDONLY, 0);
135 if (IS_ERR(fp)) {
136 pr_err("db_root: cannot open: %s\n", db_root_stage);
137 goto unlock;
138 }
139 if (!S_ISDIR(file_inode(fp)->i_mode)) {
140 filp_close(fp, NULL);
141 pr_err("db_root: not a directory: %s\n", db_root_stage);
142 goto unlock;
143 }
144 filp_close(fp, NULL);
145
146 strncpy(db_root, db_root_stage, read_bytes);
147 pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
148
149 r = read_bytes;
150
151 unlock:
152 mutex_unlock(&target_devices_lock);
153 return r;
154 }
155
156 CONFIGFS_ATTR(target_core_item_, dbroot);
157
target_core_get_fabric(const char * name)158 static struct target_fabric_configfs *target_core_get_fabric(
159 const char *name)
160 {
161 struct target_fabric_configfs *tf;
162
163 if (!name)
164 return NULL;
165
166 mutex_lock(&g_tf_lock);
167 list_for_each_entry(tf, &g_tf_list, tf_list) {
168 const char *cmp_name = tf->tf_ops->fabric_alias;
169 if (!cmp_name)
170 cmp_name = tf->tf_ops->fabric_name;
171 if (!strcmp(cmp_name, name)) {
172 atomic_inc(&tf->tf_access_cnt);
173 mutex_unlock(&g_tf_lock);
174 return tf;
175 }
176 }
177 mutex_unlock(&g_tf_lock);
178
179 return NULL;
180 }
181
182 /*
183 * Called from struct target_core_group_ops->make_group()
184 */
target_core_register_fabric(struct config_group * group,const char * name)185 static struct config_group *target_core_register_fabric(
186 struct config_group *group,
187 const char *name)
188 {
189 struct target_fabric_configfs *tf;
190 int ret;
191
192 pr_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:"
193 " %s\n", group, name);
194
195 tf = target_core_get_fabric(name);
196 if (!tf) {
197 pr_debug("target_core_register_fabric() trying autoload for %s\n",
198 name);
199
200 /*
201 * Below are some hardcoded request_module() calls to automatically
202 * local fabric modules when the following is called:
203 *
204 * mkdir -p /sys/kernel/config/target/$MODULE_NAME
205 *
206 * Note that this does not limit which TCM fabric module can be
207 * registered, but simply provids auto loading logic for modules with
208 * mkdir(2) system calls with known TCM fabric modules.
209 */
210
211 if (!strncmp(name, "iscsi", 5)) {
212 /*
213 * Automatically load the LIO Target fabric module when the
214 * following is called:
215 *
216 * mkdir -p $CONFIGFS/target/iscsi
217 */
218 ret = request_module("iscsi_target_mod");
219 if (ret < 0) {
220 pr_debug("request_module() failed for"
221 " iscsi_target_mod.ko: %d\n", ret);
222 return ERR_PTR(-EINVAL);
223 }
224 } else if (!strncmp(name, "loopback", 8)) {
225 /*
226 * Automatically load the tcm_loop fabric module when the
227 * following is called:
228 *
229 * mkdir -p $CONFIGFS/target/loopback
230 */
231 ret = request_module("tcm_loop");
232 if (ret < 0) {
233 pr_debug("request_module() failed for"
234 " tcm_loop.ko: %d\n", ret);
235 return ERR_PTR(-EINVAL);
236 }
237 }
238
239 tf = target_core_get_fabric(name);
240 }
241
242 if (!tf) {
243 pr_debug("target_core_get_fabric() failed for %s\n",
244 name);
245 return ERR_PTR(-EINVAL);
246 }
247 pr_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
248 " %s\n", tf->tf_ops->fabric_name);
249 /*
250 * On a successful target_core_get_fabric() look, the returned
251 * struct target_fabric_configfs *tf will contain a usage reference.
252 */
253 pr_debug("Target_Core_ConfigFS: REGISTER tfc_wwn_cit -> %p\n",
254 &tf->tf_wwn_cit);
255
256 config_group_init_type_name(&tf->tf_group, name, &tf->tf_wwn_cit);
257
258 config_group_init_type_name(&tf->tf_disc_group, "discovery_auth",
259 &tf->tf_discovery_cit);
260 configfs_add_default_group(&tf->tf_disc_group, &tf->tf_group);
261
262 pr_debug("Target_Core_ConfigFS: REGISTER -> Allocated Fabric: %s\n",
263 config_item_name(&tf->tf_group.cg_item));
264 return &tf->tf_group;
265 }
266
267 /*
268 * Called from struct target_core_group_ops->drop_item()
269 */
target_core_deregister_fabric(struct config_group * group,struct config_item * item)270 static void target_core_deregister_fabric(
271 struct config_group *group,
272 struct config_item *item)
273 {
274 struct target_fabric_configfs *tf = container_of(
275 to_config_group(item), struct target_fabric_configfs, tf_group);
276
277 pr_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"
278 " tf list\n", config_item_name(item));
279
280 pr_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
281 " %s\n", tf->tf_ops->fabric_name);
282 atomic_dec(&tf->tf_access_cnt);
283
284 pr_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
285 " %s\n", config_item_name(item));
286
287 configfs_remove_default_groups(&tf->tf_group);
288 config_item_put(item);
289 }
290
291 static struct configfs_group_operations target_core_fabric_group_ops = {
292 .make_group = &target_core_register_fabric,
293 .drop_item = &target_core_deregister_fabric,
294 };
295
296 /*
297 * All item attributes appearing in /sys/kernel/target/ appear here.
298 */
299 static struct configfs_attribute *target_core_fabric_item_attrs[] = {
300 &target_core_item_attr_version,
301 &target_core_item_attr_dbroot,
302 NULL,
303 };
304
305 /*
306 * Provides Fabrics Groups and Item Attributes for /sys/kernel/config/target/
307 */
308 static const struct config_item_type target_core_fabrics_item = {
309 .ct_group_ops = &target_core_fabric_group_ops,
310 .ct_attrs = target_core_fabric_item_attrs,
311 .ct_owner = THIS_MODULE,
312 };
313
314 static struct configfs_subsystem target_core_fabrics = {
315 .su_group = {
316 .cg_item = {
317 .ci_namebuf = "target",
318 .ci_type = &target_core_fabrics_item,
319 },
320 },
321 };
322
target_depend_item(struct config_item * item)323 int target_depend_item(struct config_item *item)
324 {
325 return configfs_depend_item(&target_core_fabrics, item);
326 }
327 EXPORT_SYMBOL(target_depend_item);
328
target_undepend_item(struct config_item * item)329 void target_undepend_item(struct config_item *item)
330 {
331 return configfs_undepend_item(item);
332 }
333 EXPORT_SYMBOL(target_undepend_item);
334
335 /*##############################################################################
336 // Start functions called by external Target Fabrics Modules
337 //############################################################################*/
target_disable_feature(struct se_portal_group * se_tpg)338 static int target_disable_feature(struct se_portal_group *se_tpg)
339 {
340 return 0;
341 }
342
target_default_get_inst_index(struct se_portal_group * se_tpg)343 static u32 target_default_get_inst_index(struct se_portal_group *se_tpg)
344 {
345 return 1;
346 }
347
target_default_sess_get_index(struct se_session * se_sess)348 static u32 target_default_sess_get_index(struct se_session *se_sess)
349 {
350 return 0;
351 }
352
target_set_default_node_attributes(struct se_node_acl * se_acl)353 static void target_set_default_node_attributes(struct se_node_acl *se_acl)
354 {
355 }
356
target_default_get_cmd_state(struct se_cmd * se_cmd)357 static int target_default_get_cmd_state(struct se_cmd *se_cmd)
358 {
359 return 0;
360 }
361
target_fabric_tf_ops_check(const struct target_core_fabric_ops * tfo)362 static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
363 {
364 if (tfo->fabric_alias) {
365 if (strlen(tfo->fabric_alias) >= TARGET_FABRIC_NAME_SIZE) {
366 pr_err("Passed alias: %s exceeds "
367 "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_alias);
368 return -EINVAL;
369 }
370 }
371 if (!tfo->fabric_name) {
372 pr_err("Missing tfo->fabric_name\n");
373 return -EINVAL;
374 }
375 if (strlen(tfo->fabric_name) >= TARGET_FABRIC_NAME_SIZE) {
376 pr_err("Passed name: %s exceeds "
377 "TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_name);
378 return -EINVAL;
379 }
380 if (!tfo->tpg_get_wwn) {
381 pr_err("Missing tfo->tpg_get_wwn()\n");
382 return -EINVAL;
383 }
384 if (!tfo->tpg_get_tag) {
385 pr_err("Missing tfo->tpg_get_tag()\n");
386 return -EINVAL;
387 }
388 if (!tfo->release_cmd) {
389 pr_err("Missing tfo->release_cmd()\n");
390 return -EINVAL;
391 }
392 if (!tfo->write_pending) {
393 pr_err("Missing tfo->write_pending()\n");
394 return -EINVAL;
395 }
396 if (!tfo->queue_data_in) {
397 pr_err("Missing tfo->queue_data_in()\n");
398 return -EINVAL;
399 }
400 if (!tfo->queue_status) {
401 pr_err("Missing tfo->queue_status()\n");
402 return -EINVAL;
403 }
404 if (!tfo->queue_tm_rsp) {
405 pr_err("Missing tfo->queue_tm_rsp()\n");
406 return -EINVAL;
407 }
408 if (!tfo->aborted_task) {
409 pr_err("Missing tfo->aborted_task()\n");
410 return -EINVAL;
411 }
412 if (!tfo->check_stop_free) {
413 pr_err("Missing tfo->check_stop_free()\n");
414 return -EINVAL;
415 }
416 /*
417 * We at least require tfo->fabric_make_wwn(), tfo->fabric_drop_wwn()
418 * tfo->fabric_make_tpg() and tfo->fabric_drop_tpg() in
419 * target_core_fabric_configfs.c WWN+TPG group context code.
420 */
421 if (!tfo->fabric_make_wwn) {
422 pr_err("Missing tfo->fabric_make_wwn()\n");
423 return -EINVAL;
424 }
425 if (!tfo->fabric_drop_wwn) {
426 pr_err("Missing tfo->fabric_drop_wwn()\n");
427 return -EINVAL;
428 }
429 if (!tfo->fabric_make_tpg) {
430 pr_err("Missing tfo->fabric_make_tpg()\n");
431 return -EINVAL;
432 }
433 if (!tfo->fabric_drop_tpg) {
434 pr_err("Missing tfo->fabric_drop_tpg()\n");
435 return -EINVAL;
436 }
437
438 return 0;
439 }
440
target_set_default_ops(struct target_core_fabric_ops * tfo)441 static void target_set_default_ops(struct target_core_fabric_ops *tfo)
442 {
443 if (!tfo->tpg_check_demo_mode)
444 tfo->tpg_check_demo_mode = target_disable_feature;
445
446 if (!tfo->tpg_check_demo_mode_cache)
447 tfo->tpg_check_demo_mode_cache = target_disable_feature;
448
449 if (!tfo->tpg_check_demo_mode_write_protect)
450 tfo->tpg_check_demo_mode_write_protect = target_disable_feature;
451
452 if (!tfo->tpg_check_prod_mode_write_protect)
453 tfo->tpg_check_prod_mode_write_protect = target_disable_feature;
454
455 if (!tfo->tpg_get_inst_index)
456 tfo->tpg_get_inst_index = target_default_get_inst_index;
457
458 if (!tfo->sess_get_index)
459 tfo->sess_get_index = target_default_sess_get_index;
460
461 if (!tfo->set_default_node_attributes)
462 tfo->set_default_node_attributes = target_set_default_node_attributes;
463
464 if (!tfo->get_cmd_state)
465 tfo->get_cmd_state = target_default_get_cmd_state;
466 }
467
target_register_template(const struct target_core_fabric_ops * fo)468 int target_register_template(const struct target_core_fabric_ops *fo)
469 {
470 struct target_core_fabric_ops *tfo;
471 struct target_fabric_configfs *tf;
472 int ret;
473
474 ret = target_fabric_tf_ops_check(fo);
475 if (ret)
476 return ret;
477
478 tf = kzalloc(sizeof(struct target_fabric_configfs), GFP_KERNEL);
479 if (!tf) {
480 pr_err("%s: could not allocate memory!\n", __func__);
481 return -ENOMEM;
482 }
483 tfo = kzalloc(sizeof(struct target_core_fabric_ops), GFP_KERNEL);
484 if (!tfo) {
485 kfree(tf);
486 pr_err("%s: could not allocate memory!\n", __func__);
487 return -ENOMEM;
488 }
489 memcpy(tfo, fo, sizeof(*tfo));
490 target_set_default_ops(tfo);
491
492 INIT_LIST_HEAD(&tf->tf_list);
493 atomic_set(&tf->tf_access_cnt, 0);
494 tf->tf_ops = tfo;
495 target_fabric_setup_cits(tf);
496
497 mutex_lock(&g_tf_lock);
498 list_add_tail(&tf->tf_list, &g_tf_list);
499 mutex_unlock(&g_tf_lock);
500
501 return 0;
502 }
503 EXPORT_SYMBOL(target_register_template);
504
target_unregister_template(const struct target_core_fabric_ops * fo)505 void target_unregister_template(const struct target_core_fabric_ops *fo)
506 {
507 struct target_fabric_configfs *t;
508
509 mutex_lock(&g_tf_lock);
510 list_for_each_entry(t, &g_tf_list, tf_list) {
511 if (!strcmp(t->tf_ops->fabric_name, fo->fabric_name)) {
512 BUG_ON(atomic_read(&t->tf_access_cnt));
513 list_del(&t->tf_list);
514 mutex_unlock(&g_tf_lock);
515 /*
516 * Wait for any outstanding fabric se_deve_entry->rcu_head
517 * callbacks to complete post kfree_rcu(), before allowing
518 * fabric driver unload of TFO->module to proceed.
519 */
520 rcu_barrier();
521 kfree(t->tf_tpg_base_cit.ct_attrs);
522 kfree(t->tf_ops);
523 kfree(t);
524 return;
525 }
526 }
527 mutex_unlock(&g_tf_lock);
528 }
529 EXPORT_SYMBOL(target_unregister_template);
530
531 /*##############################################################################
532 // Stop functions called by external Target Fabrics Modules
533 //############################################################################*/
534
to_attrib(struct config_item * item)535 static inline struct se_dev_attrib *to_attrib(struct config_item *item)
536 {
537 return container_of(to_config_group(item), struct se_dev_attrib,
538 da_group);
539 }
540
541 /* Start functions for struct config_item_type tb_dev_attrib_cit */
542 #define DEF_CONFIGFS_ATTRIB_SHOW(_name) \
543 static ssize_t _name##_show(struct config_item *item, char *page) \
544 { \
545 return snprintf(page, PAGE_SIZE, "%u\n", to_attrib(item)->_name); \
546 }
547
548 DEF_CONFIGFS_ATTRIB_SHOW(emulate_model_alias);
549 DEF_CONFIGFS_ATTRIB_SHOW(emulate_dpo);
550 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_write);
551 DEF_CONFIGFS_ATTRIB_SHOW(emulate_fua_read);
552 DEF_CONFIGFS_ATTRIB_SHOW(emulate_write_cache);
553 DEF_CONFIGFS_ATTRIB_SHOW(emulate_ua_intlck_ctrl);
554 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tas);
555 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpu);
556 DEF_CONFIGFS_ATTRIB_SHOW(emulate_tpws);
557 DEF_CONFIGFS_ATTRIB_SHOW(emulate_caw);
558 DEF_CONFIGFS_ATTRIB_SHOW(emulate_3pc);
559 DEF_CONFIGFS_ATTRIB_SHOW(emulate_pr);
560 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_type);
561 DEF_CONFIGFS_ATTRIB_SHOW(hw_pi_prot_type);
562 DEF_CONFIGFS_ATTRIB_SHOW(pi_prot_verify);
563 DEF_CONFIGFS_ATTRIB_SHOW(enforce_pr_isids);
564 DEF_CONFIGFS_ATTRIB_SHOW(is_nonrot);
565 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rest_reord);
566 DEF_CONFIGFS_ATTRIB_SHOW(force_pr_aptpl);
567 DEF_CONFIGFS_ATTRIB_SHOW(hw_block_size);
568 DEF_CONFIGFS_ATTRIB_SHOW(block_size);
569 DEF_CONFIGFS_ATTRIB_SHOW(hw_max_sectors);
570 DEF_CONFIGFS_ATTRIB_SHOW(optimal_sectors);
571 DEF_CONFIGFS_ATTRIB_SHOW(hw_queue_depth);
572 DEF_CONFIGFS_ATTRIB_SHOW(queue_depth);
573 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_lba_count);
574 DEF_CONFIGFS_ATTRIB_SHOW(max_unmap_block_desc_count);
575 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity);
576 DEF_CONFIGFS_ATTRIB_SHOW(unmap_granularity_alignment);
577 DEF_CONFIGFS_ATTRIB_SHOW(unmap_zeroes_data);
578 DEF_CONFIGFS_ATTRIB_SHOW(max_write_same_len);
579 DEF_CONFIGFS_ATTRIB_SHOW(emulate_rsoc);
580
581 #define DEF_CONFIGFS_ATTRIB_STORE_U32(_name) \
582 static ssize_t _name##_store(struct config_item *item, const char *page,\
583 size_t count) \
584 { \
585 struct se_dev_attrib *da = to_attrib(item); \
586 u32 val; \
587 int ret; \
588 \
589 ret = kstrtou32(page, 0, &val); \
590 if (ret < 0) \
591 return ret; \
592 da->_name = val; \
593 return count; \
594 }
595
596 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_lba_count);
597 DEF_CONFIGFS_ATTRIB_STORE_U32(max_unmap_block_desc_count);
598 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity);
599 DEF_CONFIGFS_ATTRIB_STORE_U32(unmap_granularity_alignment);
600 DEF_CONFIGFS_ATTRIB_STORE_U32(max_write_same_len);
601
602 #define DEF_CONFIGFS_ATTRIB_STORE_BOOL(_name) \
603 static ssize_t _name##_store(struct config_item *item, const char *page, \
604 size_t count) \
605 { \
606 struct se_dev_attrib *da = to_attrib(item); \
607 bool flag; \
608 int ret; \
609 \
610 ret = kstrtobool(page, &flag); \
611 if (ret < 0) \
612 return ret; \
613 da->_name = flag; \
614 return count; \
615 }
616
617 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_fua_write);
618 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_caw);
619 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_3pc);
620 DEF_CONFIGFS_ATTRIB_STORE_BOOL(emulate_pr);
621 DEF_CONFIGFS_ATTRIB_STORE_BOOL(enforce_pr_isids);
622 DEF_CONFIGFS_ATTRIB_STORE_BOOL(is_nonrot);
623
624 #define DEF_CONFIGFS_ATTRIB_STORE_STUB(_name) \
625 static ssize_t _name##_store(struct config_item *item, const char *page,\
626 size_t count) \
627 { \
628 printk_once(KERN_WARNING \
629 "ignoring deprecated %s attribute\n", \
630 __stringify(_name)); \
631 return count; \
632 }
633
634 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_dpo);
635 DEF_CONFIGFS_ATTRIB_STORE_STUB(emulate_fua_read);
636
dev_set_t10_wwn_model_alias(struct se_device * dev)637 static void dev_set_t10_wwn_model_alias(struct se_device *dev)
638 {
639 const char *configname;
640
641 configname = config_item_name(&dev->dev_group.cg_item);
642 if (strlen(configname) >= INQUIRY_MODEL_LEN) {
643 pr_warn("dev[%p]: Backstore name '%s' is too long for "
644 "INQUIRY_MODEL, truncating to 15 characters\n", dev,
645 configname);
646 }
647 /*
648 * XXX We can't use sizeof(dev->t10_wwn.model) (INQUIRY_MODEL_LEN + 1)
649 * here without potentially breaking existing setups, so continue to
650 * truncate one byte shorter than what can be carried in INQUIRY.
651 */
652 strscpy(dev->t10_wwn.model, configname, INQUIRY_MODEL_LEN);
653 }
654
emulate_model_alias_store(struct config_item * item,const char * page,size_t count)655 static ssize_t emulate_model_alias_store(struct config_item *item,
656 const char *page, size_t count)
657 {
658 struct se_dev_attrib *da = to_attrib(item);
659 struct se_device *dev = da->da_dev;
660 bool flag;
661 int ret;
662
663 if (dev->export_count) {
664 pr_err("dev[%p]: Unable to change model alias"
665 " while export_count is %d\n",
666 dev, dev->export_count);
667 return -EINVAL;
668 }
669
670 ret = kstrtobool(page, &flag);
671 if (ret < 0)
672 return ret;
673
674 BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
675 if (flag) {
676 dev_set_t10_wwn_model_alias(dev);
677 } else {
678 strscpy(dev->t10_wwn.model, dev->transport->inquiry_prod,
679 sizeof(dev->t10_wwn.model));
680 }
681 da->emulate_model_alias = flag;
682 return count;
683 }
684
emulate_write_cache_store(struct config_item * item,const char * page,size_t count)685 static ssize_t emulate_write_cache_store(struct config_item *item,
686 const char *page, size_t count)
687 {
688 struct se_dev_attrib *da = to_attrib(item);
689 bool flag;
690 int ret;
691
692 ret = kstrtobool(page, &flag);
693 if (ret < 0)
694 return ret;
695
696 if (flag && da->da_dev->transport->get_write_cache) {
697 pr_err("emulate_write_cache not supported for this device\n");
698 return -EINVAL;
699 }
700
701 da->emulate_write_cache = flag;
702 pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
703 da->da_dev, flag);
704 return count;
705 }
706
emulate_ua_intlck_ctrl_store(struct config_item * item,const char * page,size_t count)707 static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item,
708 const char *page, size_t count)
709 {
710 struct se_dev_attrib *da = to_attrib(item);
711 u32 val;
712 int ret;
713
714 ret = kstrtou32(page, 0, &val);
715 if (ret < 0)
716 return ret;
717
718 if (val != TARGET_UA_INTLCK_CTRL_CLEAR
719 && val != TARGET_UA_INTLCK_CTRL_NO_CLEAR
720 && val != TARGET_UA_INTLCK_CTRL_ESTABLISH_UA) {
721 pr_err("Illegal value %d\n", val);
722 return -EINVAL;
723 }
724
725 if (da->da_dev->export_count) {
726 pr_err("dev[%p]: Unable to change SE Device"
727 " UA_INTRLCK_CTRL while export_count is %d\n",
728 da->da_dev, da->da_dev->export_count);
729 return -EINVAL;
730 }
731 da->emulate_ua_intlck_ctrl = val;
732 pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
733 da->da_dev, val);
734 return count;
735 }
736
emulate_tas_store(struct config_item * item,const char * page,size_t count)737 static ssize_t emulate_tas_store(struct config_item *item,
738 const char *page, size_t count)
739 {
740 struct se_dev_attrib *da = to_attrib(item);
741 bool flag;
742 int ret;
743
744 ret = kstrtobool(page, &flag);
745 if (ret < 0)
746 return ret;
747
748 if (da->da_dev->export_count) {
749 pr_err("dev[%p]: Unable to change SE Device TAS while"
750 " export_count is %d\n",
751 da->da_dev, da->da_dev->export_count);
752 return -EINVAL;
753 }
754 da->emulate_tas = flag;
755 pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
756 da->da_dev, flag ? "Enabled" : "Disabled");
757
758 return count;
759 }
760
emulate_tpu_store(struct config_item * item,const char * page,size_t count)761 static ssize_t emulate_tpu_store(struct config_item *item,
762 const char *page, size_t count)
763 {
764 struct se_dev_attrib *da = to_attrib(item);
765 struct se_device *dev = da->da_dev;
766 bool flag;
767 int ret;
768
769 ret = kstrtobool(page, &flag);
770 if (ret < 0)
771 return ret;
772
773 /*
774 * We expect this value to be non-zero when generic Block Layer
775 * Discard supported is detected iblock_create_virtdevice().
776 */
777 if (flag && !da->max_unmap_block_desc_count) {
778 if (!dev->transport->configure_unmap ||
779 !dev->transport->configure_unmap(dev)) {
780 pr_err("Generic Block Discard not supported\n");
781 return -ENOSYS;
782 }
783 }
784
785 da->emulate_tpu = flag;
786 pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
787 da->da_dev, flag);
788 return count;
789 }
790
emulate_tpws_store(struct config_item * item,const char * page,size_t count)791 static ssize_t emulate_tpws_store(struct config_item *item,
792 const char *page, size_t count)
793 {
794 struct se_dev_attrib *da = to_attrib(item);
795 struct se_device *dev = da->da_dev;
796 bool flag;
797 int ret;
798
799 ret = kstrtobool(page, &flag);
800 if (ret < 0)
801 return ret;
802
803 /*
804 * We expect this value to be non-zero when generic Block Layer
805 * Discard supported is detected iblock_create_virtdevice().
806 */
807 if (flag && !da->max_unmap_block_desc_count) {
808 if (!dev->transport->configure_unmap ||
809 !dev->transport->configure_unmap(dev)) {
810 pr_err("Generic Block Discard not supported\n");
811 return -ENOSYS;
812 }
813 }
814
815 da->emulate_tpws = flag;
816 pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
817 da->da_dev, flag);
818 return count;
819 }
820
pi_prot_type_store(struct config_item * item,const char * page,size_t count)821 static ssize_t pi_prot_type_store(struct config_item *item,
822 const char *page, size_t count)
823 {
824 struct se_dev_attrib *da = to_attrib(item);
825 int old_prot = da->pi_prot_type, ret;
826 struct se_device *dev = da->da_dev;
827 u32 flag;
828
829 ret = kstrtou32(page, 0, &flag);
830 if (ret < 0)
831 return ret;
832
833 if (flag != 0 && flag != 1 && flag != 2 && flag != 3) {
834 pr_err("Illegal value %d for pi_prot_type\n", flag);
835 return -EINVAL;
836 }
837 if (flag == 2) {
838 pr_err("DIF TYPE2 protection currently not supported\n");
839 return -ENOSYS;
840 }
841 if (da->hw_pi_prot_type) {
842 pr_warn("DIF protection enabled on underlying hardware,"
843 " ignoring\n");
844 return count;
845 }
846 if (!dev->transport->init_prot || !dev->transport->free_prot) {
847 /* 0 is only allowed value for non-supporting backends */
848 if (flag == 0)
849 return count;
850
851 pr_err("DIF protection not supported by backend: %s\n",
852 dev->transport->name);
853 return -ENOSYS;
854 }
855 if (!target_dev_configured(dev)) {
856 pr_err("DIF protection requires device to be configured\n");
857 return -ENODEV;
858 }
859 if (dev->export_count) {
860 pr_err("dev[%p]: Unable to change SE Device PROT type while"
861 " export_count is %d\n", dev, dev->export_count);
862 return -EINVAL;
863 }
864
865 da->pi_prot_type = flag;
866
867 if (flag && !old_prot) {
868 ret = dev->transport->init_prot(dev);
869 if (ret) {
870 da->pi_prot_type = old_prot;
871 da->pi_prot_verify = (bool) da->pi_prot_type;
872 return ret;
873 }
874
875 } else if (!flag && old_prot) {
876 dev->transport->free_prot(dev);
877 }
878
879 da->pi_prot_verify = (bool) da->pi_prot_type;
880 pr_debug("dev[%p]: SE Device Protection Type: %d\n", dev, flag);
881 return count;
882 }
883
884 /* always zero, but attr needs to remain RW to avoid userspace breakage */
pi_prot_format_show(struct config_item * item,char * page)885 static ssize_t pi_prot_format_show(struct config_item *item, char *page)
886 {
887 return snprintf(page, PAGE_SIZE, "0\n");
888 }
889
pi_prot_format_store(struct config_item * item,const char * page,size_t count)890 static ssize_t pi_prot_format_store(struct config_item *item,
891 const char *page, size_t count)
892 {
893 struct se_dev_attrib *da = to_attrib(item);
894 struct se_device *dev = da->da_dev;
895 bool flag;
896 int ret;
897
898 ret = kstrtobool(page, &flag);
899 if (ret < 0)
900 return ret;
901
902 if (!flag)
903 return count;
904
905 if (!dev->transport->format_prot) {
906 pr_err("DIF protection format not supported by backend %s\n",
907 dev->transport->name);
908 return -ENOSYS;
909 }
910 if (!target_dev_configured(dev)) {
911 pr_err("DIF protection format requires device to be configured\n");
912 return -ENODEV;
913 }
914 if (dev->export_count) {
915 pr_err("dev[%p]: Unable to format SE Device PROT type while"
916 " export_count is %d\n", dev, dev->export_count);
917 return -EINVAL;
918 }
919
920 ret = dev->transport->format_prot(dev);
921 if (ret)
922 return ret;
923
924 pr_debug("dev[%p]: SE Device Protection Format complete\n", dev);
925 return count;
926 }
927
pi_prot_verify_store(struct config_item * item,const char * page,size_t count)928 static ssize_t pi_prot_verify_store(struct config_item *item,
929 const char *page, size_t count)
930 {
931 struct se_dev_attrib *da = to_attrib(item);
932 bool flag;
933 int ret;
934
935 ret = kstrtobool(page, &flag);
936 if (ret < 0)
937 return ret;
938
939 if (!flag) {
940 da->pi_prot_verify = flag;
941 return count;
942 }
943 if (da->hw_pi_prot_type) {
944 pr_warn("DIF protection enabled on underlying hardware,"
945 " ignoring\n");
946 return count;
947 }
948 if (!da->pi_prot_type) {
949 pr_warn("DIF protection not supported by backend, ignoring\n");
950 return count;
951 }
952 da->pi_prot_verify = flag;
953
954 return count;
955 }
956
force_pr_aptpl_store(struct config_item * item,const char * page,size_t count)957 static ssize_t force_pr_aptpl_store(struct config_item *item,
958 const char *page, size_t count)
959 {
960 struct se_dev_attrib *da = to_attrib(item);
961 bool flag;
962 int ret;
963
964 ret = kstrtobool(page, &flag);
965 if (ret < 0)
966 return ret;
967 if (da->da_dev->export_count) {
968 pr_err("dev[%p]: Unable to set force_pr_aptpl while"
969 " export_count is %d\n",
970 da->da_dev, da->da_dev->export_count);
971 return -EINVAL;
972 }
973
974 da->force_pr_aptpl = flag;
975 pr_debug("dev[%p]: SE Device force_pr_aptpl: %d\n", da->da_dev, flag);
976 return count;
977 }
978
emulate_rest_reord_store(struct config_item * item,const char * page,size_t count)979 static ssize_t emulate_rest_reord_store(struct config_item *item,
980 const char *page, size_t count)
981 {
982 struct se_dev_attrib *da = to_attrib(item);
983 bool flag;
984 int ret;
985
986 ret = kstrtobool(page, &flag);
987 if (ret < 0)
988 return ret;
989
990 if (flag != 0) {
991 printk(KERN_ERR "dev[%p]: SE Device emulation of restricted"
992 " reordering not implemented\n", da->da_dev);
993 return -ENOSYS;
994 }
995 da->emulate_rest_reord = flag;
996 pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n",
997 da->da_dev, flag);
998 return count;
999 }
1000
unmap_zeroes_data_store(struct config_item * item,const char * page,size_t count)1001 static ssize_t unmap_zeroes_data_store(struct config_item *item,
1002 const char *page, size_t count)
1003 {
1004 struct se_dev_attrib *da = to_attrib(item);
1005 struct se_device *dev = da->da_dev;
1006 bool flag;
1007 int ret;
1008
1009 ret = kstrtobool(page, &flag);
1010 if (ret < 0)
1011 return ret;
1012
1013 if (da->da_dev->export_count) {
1014 pr_err("dev[%p]: Unable to change SE Device"
1015 " unmap_zeroes_data while export_count is %d\n",
1016 da->da_dev, da->da_dev->export_count);
1017 return -EINVAL;
1018 }
1019 /*
1020 * We expect this value to be non-zero when generic Block Layer
1021 * Discard supported is detected iblock_configure_device().
1022 */
1023 if (flag && !da->max_unmap_block_desc_count) {
1024 if (!dev->transport->configure_unmap ||
1025 !dev->transport->configure_unmap(dev)) {
1026 pr_err("dev[%p]: Thin Provisioning LBPRZ will not be set because max_unmap_block_desc_count is zero\n",
1027 da->da_dev);
1028 return -ENOSYS;
1029 }
1030 }
1031 da->unmap_zeroes_data = flag;
1032 pr_debug("dev[%p]: SE Device Thin Provisioning LBPRZ bit: %d\n",
1033 da->da_dev, flag);
1034 return count;
1035 }
1036
1037 /*
1038 * Note, this can only be called on unexported SE Device Object.
1039 */
queue_depth_store(struct config_item * item,const char * page,size_t count)1040 static ssize_t queue_depth_store(struct config_item *item,
1041 const char *page, size_t count)
1042 {
1043 struct se_dev_attrib *da = to_attrib(item);
1044 struct se_device *dev = da->da_dev;
1045 u32 val;
1046 int ret;
1047
1048 ret = kstrtou32(page, 0, &val);
1049 if (ret < 0)
1050 return ret;
1051
1052 if (dev->export_count) {
1053 pr_err("dev[%p]: Unable to change SE Device TCQ while"
1054 " export_count is %d\n",
1055 dev, dev->export_count);
1056 return -EINVAL;
1057 }
1058 if (!val) {
1059 pr_err("dev[%p]: Illegal ZERO value for queue_depth\n", dev);
1060 return -EINVAL;
1061 }
1062
1063 if (val > dev->dev_attrib.queue_depth) {
1064 if (val > dev->dev_attrib.hw_queue_depth) {
1065 pr_err("dev[%p]: Passed queue_depth:"
1066 " %u exceeds TCM/SE_Device MAX"
1067 " TCQ: %u\n", dev, val,
1068 dev->dev_attrib.hw_queue_depth);
1069 return -EINVAL;
1070 }
1071 }
1072 da->queue_depth = dev->queue_depth = val;
1073 pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n", dev, val);
1074 return count;
1075 }
1076
optimal_sectors_store(struct config_item * item,const char * page,size_t count)1077 static ssize_t optimal_sectors_store(struct config_item *item,
1078 const char *page, size_t count)
1079 {
1080 struct se_dev_attrib *da = to_attrib(item);
1081 u32 val;
1082 int ret;
1083
1084 ret = kstrtou32(page, 0, &val);
1085 if (ret < 0)
1086 return ret;
1087
1088 if (da->da_dev->export_count) {
1089 pr_err("dev[%p]: Unable to change SE Device"
1090 " optimal_sectors while export_count is %d\n",
1091 da->da_dev, da->da_dev->export_count);
1092 return -EINVAL;
1093 }
1094 if (val > da->hw_max_sectors) {
1095 pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
1096 " greater than hw_max_sectors: %u\n",
1097 da->da_dev, val, da->hw_max_sectors);
1098 return -EINVAL;
1099 }
1100
1101 da->optimal_sectors = val;
1102 pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
1103 da->da_dev, val);
1104 return count;
1105 }
1106
block_size_store(struct config_item * item,const char * page,size_t count)1107 static ssize_t block_size_store(struct config_item *item,
1108 const char *page, size_t count)
1109 {
1110 struct se_dev_attrib *da = to_attrib(item);
1111 u32 val;
1112 int ret;
1113
1114 ret = kstrtou32(page, 0, &val);
1115 if (ret < 0)
1116 return ret;
1117
1118 if (da->da_dev->export_count) {
1119 pr_err("dev[%p]: Unable to change SE Device block_size"
1120 " while export_count is %d\n",
1121 da->da_dev, da->da_dev->export_count);
1122 return -EINVAL;
1123 }
1124
1125 if (val != 512 && val != 1024 && val != 2048 && val != 4096) {
1126 pr_err("dev[%p]: Illegal value for block_device: %u"
1127 " for SE device, must be 512, 1024, 2048 or 4096\n",
1128 da->da_dev, val);
1129 return -EINVAL;
1130 }
1131
1132 da->block_size = val;
1133
1134 pr_debug("dev[%p]: SE Device block_size changed to %u\n",
1135 da->da_dev, val);
1136 return count;
1137 }
1138
alua_support_show(struct config_item * item,char * page)1139 static ssize_t alua_support_show(struct config_item *item, char *page)
1140 {
1141 struct se_dev_attrib *da = to_attrib(item);
1142 u8 flags = da->da_dev->transport_flags;
1143
1144 return snprintf(page, PAGE_SIZE, "%d\n",
1145 flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA ? 0 : 1);
1146 }
1147
alua_support_store(struct config_item * item,const char * page,size_t count)1148 static ssize_t alua_support_store(struct config_item *item,
1149 const char *page, size_t count)
1150 {
1151 struct se_dev_attrib *da = to_attrib(item);
1152 struct se_device *dev = da->da_dev;
1153 bool flag, oldflag;
1154 int ret;
1155
1156 ret = kstrtobool(page, &flag);
1157 if (ret < 0)
1158 return ret;
1159
1160 oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA);
1161 if (flag == oldflag)
1162 return count;
1163
1164 if (!(dev->transport->transport_flags_changeable &
1165 TRANSPORT_FLAG_PASSTHROUGH_ALUA)) {
1166 pr_err("dev[%p]: Unable to change SE Device alua_support:"
1167 " alua_support has fixed value\n", dev);
1168 return -ENOSYS;
1169 }
1170
1171 if (flag)
1172 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_ALUA;
1173 else
1174 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_ALUA;
1175 return count;
1176 }
1177
pgr_support_show(struct config_item * item,char * page)1178 static ssize_t pgr_support_show(struct config_item *item, char *page)
1179 {
1180 struct se_dev_attrib *da = to_attrib(item);
1181 u8 flags = da->da_dev->transport_flags;
1182
1183 return snprintf(page, PAGE_SIZE, "%d\n",
1184 flags & TRANSPORT_FLAG_PASSTHROUGH_PGR ? 0 : 1);
1185 }
1186
pgr_support_store(struct config_item * item,const char * page,size_t count)1187 static ssize_t pgr_support_store(struct config_item *item,
1188 const char *page, size_t count)
1189 {
1190 struct se_dev_attrib *da = to_attrib(item);
1191 struct se_device *dev = da->da_dev;
1192 bool flag, oldflag;
1193 int ret;
1194
1195 ret = kstrtobool(page, &flag);
1196 if (ret < 0)
1197 return ret;
1198
1199 oldflag = !(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR);
1200 if (flag == oldflag)
1201 return count;
1202
1203 if (!(dev->transport->transport_flags_changeable &
1204 TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
1205 pr_err("dev[%p]: Unable to change SE Device pgr_support:"
1206 " pgr_support has fixed value\n", dev);
1207 return -ENOSYS;
1208 }
1209
1210 if (flag)
1211 dev->transport_flags &= ~TRANSPORT_FLAG_PASSTHROUGH_PGR;
1212 else
1213 dev->transport_flags |= TRANSPORT_FLAG_PASSTHROUGH_PGR;
1214 return count;
1215 }
1216
emulate_rsoc_store(struct config_item * item,const char * page,size_t count)1217 static ssize_t emulate_rsoc_store(struct config_item *item,
1218 const char *page, size_t count)
1219 {
1220 struct se_dev_attrib *da = to_attrib(item);
1221 bool flag;
1222 int ret;
1223
1224 ret = kstrtobool(page, &flag);
1225 if (ret < 0)
1226 return ret;
1227
1228 da->emulate_rsoc = flag;
1229 pr_debug("dev[%p]: SE Device REPORT_SUPPORTED_OPERATION_CODES_EMULATION flag: %d\n",
1230 da->da_dev, flag);
1231 return count;
1232 }
1233
1234 CONFIGFS_ATTR(, emulate_model_alias);
1235 CONFIGFS_ATTR(, emulate_dpo);
1236 CONFIGFS_ATTR(, emulate_fua_write);
1237 CONFIGFS_ATTR(, emulate_fua_read);
1238 CONFIGFS_ATTR(, emulate_write_cache);
1239 CONFIGFS_ATTR(, emulate_ua_intlck_ctrl);
1240 CONFIGFS_ATTR(, emulate_tas);
1241 CONFIGFS_ATTR(, emulate_tpu);
1242 CONFIGFS_ATTR(, emulate_tpws);
1243 CONFIGFS_ATTR(, emulate_caw);
1244 CONFIGFS_ATTR(, emulate_3pc);
1245 CONFIGFS_ATTR(, emulate_pr);
1246 CONFIGFS_ATTR(, emulate_rsoc);
1247 CONFIGFS_ATTR(, pi_prot_type);
1248 CONFIGFS_ATTR_RO(, hw_pi_prot_type);
1249 CONFIGFS_ATTR(, pi_prot_format);
1250 CONFIGFS_ATTR(, pi_prot_verify);
1251 CONFIGFS_ATTR(, enforce_pr_isids);
1252 CONFIGFS_ATTR(, is_nonrot);
1253 CONFIGFS_ATTR(, emulate_rest_reord);
1254 CONFIGFS_ATTR(, force_pr_aptpl);
1255 CONFIGFS_ATTR_RO(, hw_block_size);
1256 CONFIGFS_ATTR(, block_size);
1257 CONFIGFS_ATTR_RO(, hw_max_sectors);
1258 CONFIGFS_ATTR(, optimal_sectors);
1259 CONFIGFS_ATTR_RO(, hw_queue_depth);
1260 CONFIGFS_ATTR(, queue_depth);
1261 CONFIGFS_ATTR(, max_unmap_lba_count);
1262 CONFIGFS_ATTR(, max_unmap_block_desc_count);
1263 CONFIGFS_ATTR(, unmap_granularity);
1264 CONFIGFS_ATTR(, unmap_granularity_alignment);
1265 CONFIGFS_ATTR(, unmap_zeroes_data);
1266 CONFIGFS_ATTR(, max_write_same_len);
1267 CONFIGFS_ATTR(, alua_support);
1268 CONFIGFS_ATTR(, pgr_support);
1269
1270 /*
1271 * dev_attrib attributes for devices using the target core SBC/SPC
1272 * interpreter. Any backend using spc_parse_cdb should be using
1273 * these.
1274 */
1275 struct configfs_attribute *sbc_attrib_attrs[] = {
1276 &attr_emulate_model_alias,
1277 &attr_emulate_dpo,
1278 &attr_emulate_fua_write,
1279 &attr_emulate_fua_read,
1280 &attr_emulate_write_cache,
1281 &attr_emulate_ua_intlck_ctrl,
1282 &attr_emulate_tas,
1283 &attr_emulate_tpu,
1284 &attr_emulate_tpws,
1285 &attr_emulate_caw,
1286 &attr_emulate_3pc,
1287 &attr_emulate_pr,
1288 &attr_pi_prot_type,
1289 &attr_hw_pi_prot_type,
1290 &attr_pi_prot_format,
1291 &attr_pi_prot_verify,
1292 &attr_enforce_pr_isids,
1293 &attr_is_nonrot,
1294 &attr_emulate_rest_reord,
1295 &attr_force_pr_aptpl,
1296 &attr_hw_block_size,
1297 &attr_block_size,
1298 &attr_hw_max_sectors,
1299 &attr_optimal_sectors,
1300 &attr_hw_queue_depth,
1301 &attr_queue_depth,
1302 &attr_max_unmap_lba_count,
1303 &attr_max_unmap_block_desc_count,
1304 &attr_unmap_granularity,
1305 &attr_unmap_granularity_alignment,
1306 &attr_unmap_zeroes_data,
1307 &attr_max_write_same_len,
1308 &attr_alua_support,
1309 &attr_pgr_support,
1310 &attr_emulate_rsoc,
1311 NULL,
1312 };
1313 EXPORT_SYMBOL(sbc_attrib_attrs);
1314
1315 /*
1316 * Minimal dev_attrib attributes for devices passing through CDBs.
1317 * In this case we only provide a few read-only attributes for
1318 * backwards compatibility.
1319 */
1320 struct configfs_attribute *passthrough_attrib_attrs[] = {
1321 &attr_hw_pi_prot_type,
1322 &attr_hw_block_size,
1323 &attr_hw_max_sectors,
1324 &attr_hw_queue_depth,
1325 &attr_emulate_pr,
1326 &attr_alua_support,
1327 &attr_pgr_support,
1328 NULL,
1329 };
1330 EXPORT_SYMBOL(passthrough_attrib_attrs);
1331
1332 /*
1333 * pr related dev_attrib attributes for devices passing through CDBs,
1334 * but allowing in core pr emulation.
1335 */
1336 struct configfs_attribute *passthrough_pr_attrib_attrs[] = {
1337 &attr_enforce_pr_isids,
1338 &attr_force_pr_aptpl,
1339 NULL,
1340 };
1341 EXPORT_SYMBOL(passthrough_pr_attrib_attrs);
1342
1343 TB_CIT_SETUP_DRV(dev_attrib, NULL, NULL);
1344 TB_CIT_SETUP_DRV(dev_action, NULL, NULL);
1345
1346 /* End functions for struct config_item_type tb_dev_attrib_cit */
1347
1348 /* Start functions for struct config_item_type tb_dev_wwn_cit */
1349
to_t10_wwn(struct config_item * item)1350 static struct t10_wwn *to_t10_wwn(struct config_item *item)
1351 {
1352 return container_of(to_config_group(item), struct t10_wwn, t10_wwn_group);
1353 }
1354
target_check_inquiry_data(char * buf)1355 static ssize_t target_check_inquiry_data(char *buf)
1356 {
1357 size_t len;
1358 int i;
1359
1360 len = strlen(buf);
1361
1362 /*
1363 * SPC 4.3.1:
1364 * ASCII data fields shall contain only ASCII printable characters
1365 * (i.e., code values 20h to 7Eh) and may be terminated with one or
1366 * more ASCII null (00h) characters.
1367 */
1368 for (i = 0; i < len; i++) {
1369 if (buf[i] < 0x20 || buf[i] > 0x7E) {
1370 pr_err("Emulated T10 Inquiry Data contains non-ASCII-printable characters\n");
1371 return -EINVAL;
1372 }
1373 }
1374
1375 return len;
1376 }
1377
1378 /*
1379 * STANDARD and VPD page 0x83 T10 Vendor Identification
1380 */
target_wwn_vendor_id_show(struct config_item * item,char * page)1381 static ssize_t target_wwn_vendor_id_show(struct config_item *item,
1382 char *page)
1383 {
1384 return sprintf(page, "%s\n", &to_t10_wwn(item)->vendor[0]);
1385 }
1386
target_wwn_vendor_id_store(struct config_item * item,const char * page,size_t count)1387 static ssize_t target_wwn_vendor_id_store(struct config_item *item,
1388 const char *page, size_t count)
1389 {
1390 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1391 struct se_device *dev = t10_wwn->t10_dev;
1392 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1393 unsigned char buf[INQUIRY_VENDOR_LEN + 2];
1394 char *stripped = NULL;
1395 ssize_t len;
1396 ssize_t ret;
1397
1398 len = strscpy(buf, page, sizeof(buf));
1399 if (len > 0) {
1400 /* Strip any newline added from userspace. */
1401 stripped = strstrip(buf);
1402 len = strlen(stripped);
1403 }
1404 if (len < 0 || len > INQUIRY_VENDOR_LEN) {
1405 pr_err("Emulated T10 Vendor Identification exceeds"
1406 " INQUIRY_VENDOR_LEN: " __stringify(INQUIRY_VENDOR_LEN)
1407 "\n");
1408 return -EOVERFLOW;
1409 }
1410
1411 ret = target_check_inquiry_data(stripped);
1412
1413 if (ret < 0)
1414 return ret;
1415
1416 /*
1417 * Check to see if any active exports exist. If they do exist, fail
1418 * here as changing this information on the fly (underneath the
1419 * initiator side OS dependent multipath code) could cause negative
1420 * effects.
1421 */
1422 if (dev->export_count) {
1423 pr_err("Unable to set T10 Vendor Identification while"
1424 " active %d exports exist\n", dev->export_count);
1425 return -EINVAL;
1426 }
1427
1428 BUILD_BUG_ON(sizeof(dev->t10_wwn.vendor) != INQUIRY_VENDOR_LEN + 1);
1429 strscpy(dev->t10_wwn.vendor, stripped, sizeof(dev->t10_wwn.vendor));
1430
1431 pr_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification:"
1432 " %s\n", dev->t10_wwn.vendor);
1433
1434 return count;
1435 }
1436
target_wwn_product_id_show(struct config_item * item,char * page)1437 static ssize_t target_wwn_product_id_show(struct config_item *item,
1438 char *page)
1439 {
1440 return sprintf(page, "%s\n", &to_t10_wwn(item)->model[0]);
1441 }
1442
target_wwn_product_id_store(struct config_item * item,const char * page,size_t count)1443 static ssize_t target_wwn_product_id_store(struct config_item *item,
1444 const char *page, size_t count)
1445 {
1446 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1447 struct se_device *dev = t10_wwn->t10_dev;
1448 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1449 unsigned char buf[INQUIRY_MODEL_LEN + 2];
1450 char *stripped = NULL;
1451 ssize_t len;
1452 ssize_t ret;
1453
1454 len = strscpy(buf, page, sizeof(buf));
1455 if (len > 0) {
1456 /* Strip any newline added from userspace. */
1457 stripped = strstrip(buf);
1458 len = strlen(stripped);
1459 }
1460 if (len < 0 || len > INQUIRY_MODEL_LEN) {
1461 pr_err("Emulated T10 Vendor exceeds INQUIRY_MODEL_LEN: "
1462 __stringify(INQUIRY_MODEL_LEN)
1463 "\n");
1464 return -EOVERFLOW;
1465 }
1466
1467 ret = target_check_inquiry_data(stripped);
1468
1469 if (ret < 0)
1470 return ret;
1471
1472 /*
1473 * Check to see if any active exports exist. If they do exist, fail
1474 * here as changing this information on the fly (underneath the
1475 * initiator side OS dependent multipath code) could cause negative
1476 * effects.
1477 */
1478 if (dev->export_count) {
1479 pr_err("Unable to set T10 Model while active %d exports exist\n",
1480 dev->export_count);
1481 return -EINVAL;
1482 }
1483
1484 BUILD_BUG_ON(sizeof(dev->t10_wwn.model) != INQUIRY_MODEL_LEN + 1);
1485 strscpy(dev->t10_wwn.model, stripped, sizeof(dev->t10_wwn.model));
1486
1487 pr_debug("Target_Core_ConfigFS: Set emulated T10 Model Identification: %s\n",
1488 dev->t10_wwn.model);
1489
1490 return count;
1491 }
1492
target_wwn_revision_show(struct config_item * item,char * page)1493 static ssize_t target_wwn_revision_show(struct config_item *item,
1494 char *page)
1495 {
1496 return sprintf(page, "%s\n", &to_t10_wwn(item)->revision[0]);
1497 }
1498
target_wwn_revision_store(struct config_item * item,const char * page,size_t count)1499 static ssize_t target_wwn_revision_store(struct config_item *item,
1500 const char *page, size_t count)
1501 {
1502 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1503 struct se_device *dev = t10_wwn->t10_dev;
1504 /* +2 to allow for a trailing (stripped) '\n' and null-terminator */
1505 unsigned char buf[INQUIRY_REVISION_LEN + 2];
1506 char *stripped = NULL;
1507 ssize_t len;
1508 ssize_t ret;
1509
1510 len = strscpy(buf, page, sizeof(buf));
1511 if (len > 0) {
1512 /* Strip any newline added from userspace. */
1513 stripped = strstrip(buf);
1514 len = strlen(stripped);
1515 }
1516 if (len < 0 || len > INQUIRY_REVISION_LEN) {
1517 pr_err("Emulated T10 Revision exceeds INQUIRY_REVISION_LEN: "
1518 __stringify(INQUIRY_REVISION_LEN)
1519 "\n");
1520 return -EOVERFLOW;
1521 }
1522
1523 ret = target_check_inquiry_data(stripped);
1524
1525 if (ret < 0)
1526 return ret;
1527
1528 /*
1529 * Check to see if any active exports exist. If they do exist, fail
1530 * here as changing this information on the fly (underneath the
1531 * initiator side OS dependent multipath code) could cause negative
1532 * effects.
1533 */
1534 if (dev->export_count) {
1535 pr_err("Unable to set T10 Revision while active %d exports exist\n",
1536 dev->export_count);
1537 return -EINVAL;
1538 }
1539
1540 BUILD_BUG_ON(sizeof(dev->t10_wwn.revision) != INQUIRY_REVISION_LEN + 1);
1541 strscpy(dev->t10_wwn.revision, stripped, sizeof(dev->t10_wwn.revision));
1542
1543 pr_debug("Target_Core_ConfigFS: Set emulated T10 Revision: %s\n",
1544 dev->t10_wwn.revision);
1545
1546 return count;
1547 }
1548
1549 static ssize_t
target_wwn_company_id_show(struct config_item * item,char * page)1550 target_wwn_company_id_show(struct config_item *item,
1551 char *page)
1552 {
1553 return snprintf(page, PAGE_SIZE, "%#08x\n",
1554 to_t10_wwn(item)->company_id);
1555 }
1556
1557 static ssize_t
target_wwn_company_id_store(struct config_item * item,const char * page,size_t count)1558 target_wwn_company_id_store(struct config_item *item,
1559 const char *page, size_t count)
1560 {
1561 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1562 struct se_device *dev = t10_wwn->t10_dev;
1563 u32 val;
1564 int ret;
1565
1566 /*
1567 * The IEEE COMPANY_ID field should contain a 24-bit canonical
1568 * form OUI assigned by the IEEE.
1569 */
1570 ret = kstrtou32(page, 0, &val);
1571 if (ret < 0)
1572 return ret;
1573
1574 if (val >= 0x1000000)
1575 return -EOVERFLOW;
1576
1577 /*
1578 * Check to see if any active exports exist. If they do exist, fail
1579 * here as changing this information on the fly (underneath the
1580 * initiator side OS dependent multipath code) could cause negative
1581 * effects.
1582 */
1583 if (dev->export_count) {
1584 pr_err("Unable to set Company ID while %u exports exist\n",
1585 dev->export_count);
1586 return -EINVAL;
1587 }
1588
1589 t10_wwn->company_id = val;
1590
1591 pr_debug("Target_Core_ConfigFS: Set IEEE Company ID: %#08x\n",
1592 t10_wwn->company_id);
1593
1594 return count;
1595 }
1596
1597 /*
1598 * VPD page 0x80 Unit serial
1599 */
target_wwn_vpd_unit_serial_show(struct config_item * item,char * page)1600 static ssize_t target_wwn_vpd_unit_serial_show(struct config_item *item,
1601 char *page)
1602 {
1603 return sprintf(page, "T10 VPD Unit Serial Number: %s\n",
1604 &to_t10_wwn(item)->unit_serial[0]);
1605 }
1606
target_wwn_vpd_unit_serial_store(struct config_item * item,const char * page,size_t count)1607 static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
1608 const char *page, size_t count)
1609 {
1610 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1611 struct se_device *dev = t10_wwn->t10_dev;
1612 unsigned char buf[INQUIRY_VPD_SERIAL_LEN] = { };
1613
1614 /*
1615 * If Linux/SCSI subsystem_api_t plugin got a VPD Unit Serial
1616 * from the struct scsi_device level firmware, do not allow
1617 * VPD Unit Serial to be emulated.
1618 *
1619 * Note this struct scsi_device could also be emulating VPD
1620 * information from its drivers/scsi LLD. But for now we assume
1621 * it is doing 'the right thing' wrt a world wide unique
1622 * VPD Unit Serial Number that OS dependent multipath can depend on.
1623 */
1624 if (dev->dev_flags & DF_FIRMWARE_VPD_UNIT_SERIAL) {
1625 pr_err("Underlying SCSI device firmware provided VPD"
1626 " Unit Serial, ignoring request\n");
1627 return -EOPNOTSUPP;
1628 }
1629
1630 if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) {
1631 pr_err("Emulated VPD Unit Serial exceeds"
1632 " INQUIRY_VPD_SERIAL_LEN: %d\n", INQUIRY_VPD_SERIAL_LEN);
1633 return -EOVERFLOW;
1634 }
1635 /*
1636 * Check to see if any active $FABRIC_MOD exports exist. If they
1637 * do exist, fail here as changing this information on the fly
1638 * (underneath the initiator side OS dependent multipath code)
1639 * could cause negative effects.
1640 */
1641 if (dev->export_count) {
1642 pr_err("Unable to set VPD Unit Serial while"
1643 " active %d $FABRIC_MOD exports exist\n",
1644 dev->export_count);
1645 return -EINVAL;
1646 }
1647
1648 /*
1649 * This currently assumes ASCII encoding for emulated VPD Unit Serial.
1650 *
1651 * Also, strip any newline added from the userspace
1652 * echo $UUID > $TARGET/$HBA/$STORAGE_OBJECT/wwn/vpd_unit_serial
1653 */
1654 snprintf(buf, INQUIRY_VPD_SERIAL_LEN, "%s", page);
1655 snprintf(dev->t10_wwn.unit_serial, INQUIRY_VPD_SERIAL_LEN,
1656 "%s", strstrip(buf));
1657 dev->dev_flags |= DF_EMULATED_VPD_UNIT_SERIAL;
1658
1659 pr_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:"
1660 " %s\n", dev->t10_wwn.unit_serial);
1661
1662 return count;
1663 }
1664
1665 /*
1666 * VPD page 0x83 Protocol Identifier
1667 */
target_wwn_vpd_protocol_identifier_show(struct config_item * item,char * page)1668 static ssize_t target_wwn_vpd_protocol_identifier_show(struct config_item *item,
1669 char *page)
1670 {
1671 struct t10_wwn *t10_wwn = to_t10_wwn(item);
1672 struct t10_vpd *vpd;
1673 unsigned char buf[VPD_TMP_BUF_SIZE] = { };
1674 ssize_t len = 0;
1675
1676 spin_lock(&t10_wwn->t10_vpd_lock);
1677 list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) {
1678 if (!vpd->protocol_identifier_set)
1679 continue;
1680
1681 transport_dump_vpd_proto_id(vpd, buf, VPD_TMP_BUF_SIZE);
1682
1683 if (len + strlen(buf) >= PAGE_SIZE)
1684 break;
1685
1686 len += sprintf(page+len, "%s", buf);
1687 }
1688 spin_unlock(&t10_wwn->t10_vpd_lock);
1689
1690 return len;
1691 }
1692
1693 /*
1694 * Generic wrapper for dumping VPD identifiers by association.
1695 */
1696 #define DEF_DEV_WWN_ASSOC_SHOW(_name, _assoc) \
1697 static ssize_t target_wwn_##_name##_show(struct config_item *item, \
1698 char *page) \
1699 { \
1700 struct t10_wwn *t10_wwn = to_t10_wwn(item); \
1701 struct t10_vpd *vpd; \
1702 unsigned char buf[VPD_TMP_BUF_SIZE]; \
1703 ssize_t len = 0; \
1704 \
1705 spin_lock(&t10_wwn->t10_vpd_lock); \
1706 list_for_each_entry(vpd, &t10_wwn->t10_vpd_list, vpd_list) { \
1707 if (vpd->association != _assoc) \
1708 continue; \
1709 \
1710 memset(buf, 0, VPD_TMP_BUF_SIZE); \
1711 transport_dump_vpd_assoc(vpd, buf, VPD_TMP_BUF_SIZE); \
1712 if (len + strlen(buf) >= PAGE_SIZE) \
1713 break; \
1714 len += sprintf(page+len, "%s", buf); \
1715 \
1716 memset(buf, 0, VPD_TMP_BUF_SIZE); \
1717 transport_dump_vpd_ident_type(vpd, buf, VPD_TMP_BUF_SIZE); \
1718 if (len + strlen(buf) >= PAGE_SIZE) \
1719 break; \
1720 len += sprintf(page+len, "%s", buf); \
1721 \
1722 memset(buf, 0, VPD_TMP_BUF_SIZE); \
1723 transport_dump_vpd_ident(vpd, buf, VPD_TMP_BUF_SIZE); \
1724 if (len + strlen(buf) >= PAGE_SIZE) \
1725 break; \
1726 len += sprintf(page+len, "%s", buf); \
1727 } \
1728 spin_unlock(&t10_wwn->t10_vpd_lock); \
1729 \
1730 return len; \
1731 }
1732
1733 /* VPD page 0x83 Association: Logical Unit */
1734 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_logical_unit, 0x00);
1735 /* VPD page 0x83 Association: Target Port */
1736 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_target_port, 0x10);
1737 /* VPD page 0x83 Association: SCSI Target Device */
1738 DEF_DEV_WWN_ASSOC_SHOW(vpd_assoc_scsi_target_device, 0x20);
1739
1740 CONFIGFS_ATTR(target_wwn_, vendor_id);
1741 CONFIGFS_ATTR(target_wwn_, product_id);
1742 CONFIGFS_ATTR(target_wwn_, revision);
1743 CONFIGFS_ATTR(target_wwn_, company_id);
1744 CONFIGFS_ATTR(target_wwn_, vpd_unit_serial);
1745 CONFIGFS_ATTR_RO(target_wwn_, vpd_protocol_identifier);
1746 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_logical_unit);
1747 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_target_port);
1748 CONFIGFS_ATTR_RO(target_wwn_, vpd_assoc_scsi_target_device);
1749
1750 static struct configfs_attribute *target_core_dev_wwn_attrs[] = {
1751 &target_wwn_attr_vendor_id,
1752 &target_wwn_attr_product_id,
1753 &target_wwn_attr_revision,
1754 &target_wwn_attr_company_id,
1755 &target_wwn_attr_vpd_unit_serial,
1756 &target_wwn_attr_vpd_protocol_identifier,
1757 &target_wwn_attr_vpd_assoc_logical_unit,
1758 &target_wwn_attr_vpd_assoc_target_port,
1759 &target_wwn_attr_vpd_assoc_scsi_target_device,
1760 NULL,
1761 };
1762
1763 TB_CIT_SETUP(dev_wwn, NULL, NULL, target_core_dev_wwn_attrs);
1764
1765 /* End functions for struct config_item_type tb_dev_wwn_cit */
1766
1767 /* Start functions for struct config_item_type tb_dev_pr_cit */
1768
pr_to_dev(struct config_item * item)1769 static struct se_device *pr_to_dev(struct config_item *item)
1770 {
1771 return container_of(to_config_group(item), struct se_device,
1772 dev_pr_group);
1773 }
1774
target_core_dev_pr_show_spc3_res(struct se_device * dev,char * page)1775 static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev,
1776 char *page)
1777 {
1778 struct se_node_acl *se_nacl;
1779 struct t10_pr_registration *pr_reg;
1780 char i_buf[PR_REG_ISID_ID_LEN] = { };
1781
1782 pr_reg = dev->dev_pr_res_holder;
1783 if (!pr_reg)
1784 return sprintf(page, "No SPC-3 Reservation holder\n");
1785
1786 se_nacl = pr_reg->pr_reg_nacl;
1787 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
1788
1789 return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n",
1790 se_nacl->se_tpg->se_tpg_tfo->fabric_name,
1791 se_nacl->initiatorname, i_buf);
1792 }
1793
target_core_dev_pr_show_spc2_res(struct se_device * dev,char * page)1794 static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev,
1795 char *page)
1796 {
1797 struct se_session *sess = dev->reservation_holder;
1798 struct se_node_acl *se_nacl;
1799 ssize_t len;
1800
1801 if (sess) {
1802 se_nacl = sess->se_node_acl;
1803 len = sprintf(page,
1804 "SPC-2 Reservation: %s Initiator: %s\n",
1805 se_nacl->se_tpg->se_tpg_tfo->fabric_name,
1806 se_nacl->initiatorname);
1807 } else {
1808 len = sprintf(page, "No SPC-2 Reservation holder\n");
1809 }
1810 return len;
1811 }
1812
target_pr_res_holder_show(struct config_item * item,char * page)1813 static ssize_t target_pr_res_holder_show(struct config_item *item, char *page)
1814 {
1815 struct se_device *dev = pr_to_dev(item);
1816 int ret;
1817
1818 if (!dev->dev_attrib.emulate_pr)
1819 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
1820
1821 if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
1822 return sprintf(page, "Passthrough\n");
1823
1824 spin_lock(&dev->dev_reservation_lock);
1825 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
1826 ret = target_core_dev_pr_show_spc2_res(dev, page);
1827 else
1828 ret = target_core_dev_pr_show_spc3_res(dev, page);
1829 spin_unlock(&dev->dev_reservation_lock);
1830 return ret;
1831 }
1832
target_pr_res_pr_all_tgt_pts_show(struct config_item * item,char * page)1833 static ssize_t target_pr_res_pr_all_tgt_pts_show(struct config_item *item,
1834 char *page)
1835 {
1836 struct se_device *dev = pr_to_dev(item);
1837 ssize_t len = 0;
1838
1839 spin_lock(&dev->dev_reservation_lock);
1840 if (!dev->dev_pr_res_holder) {
1841 len = sprintf(page, "No SPC-3 Reservation holder\n");
1842 } else if (dev->dev_pr_res_holder->pr_reg_all_tg_pt) {
1843 len = sprintf(page, "SPC-3 Reservation: All Target"
1844 " Ports registration\n");
1845 } else {
1846 len = sprintf(page, "SPC-3 Reservation: Single"
1847 " Target Port registration\n");
1848 }
1849
1850 spin_unlock(&dev->dev_reservation_lock);
1851 return len;
1852 }
1853
target_pr_res_pr_generation_show(struct config_item * item,char * page)1854 static ssize_t target_pr_res_pr_generation_show(struct config_item *item,
1855 char *page)
1856 {
1857 return sprintf(page, "0x%08x\n", pr_to_dev(item)->t10_pr.pr_generation);
1858 }
1859
1860
target_pr_res_pr_holder_tg_port_show(struct config_item * item,char * page)1861 static ssize_t target_pr_res_pr_holder_tg_port_show(struct config_item *item,
1862 char *page)
1863 {
1864 struct se_device *dev = pr_to_dev(item);
1865 struct se_node_acl *se_nacl;
1866 struct se_portal_group *se_tpg;
1867 struct t10_pr_registration *pr_reg;
1868 const struct target_core_fabric_ops *tfo;
1869 ssize_t len = 0;
1870
1871 spin_lock(&dev->dev_reservation_lock);
1872 pr_reg = dev->dev_pr_res_holder;
1873 if (!pr_reg) {
1874 len = sprintf(page, "No SPC-3 Reservation holder\n");
1875 goto out_unlock;
1876 }
1877
1878 se_nacl = pr_reg->pr_reg_nacl;
1879 se_tpg = se_nacl->se_tpg;
1880 tfo = se_tpg->se_tpg_tfo;
1881
1882 len += sprintf(page+len, "SPC-3 Reservation: %s"
1883 " Target Node Endpoint: %s\n", tfo->fabric_name,
1884 tfo->tpg_get_wwn(se_tpg));
1885 len += sprintf(page+len, "SPC-3 Reservation: Relative Port"
1886 " Identifier Tag: %hu %s Portal Group Tag: %hu"
1887 " %s Logical Unit: %llu\n", pr_reg->tg_pt_sep_rtpi,
1888 tfo->fabric_name, tfo->tpg_get_tag(se_tpg),
1889 tfo->fabric_name, pr_reg->pr_aptpl_target_lun);
1890
1891 out_unlock:
1892 spin_unlock(&dev->dev_reservation_lock);
1893 return len;
1894 }
1895
1896
target_pr_res_pr_registered_i_pts_show(struct config_item * item,char * page)1897 static ssize_t target_pr_res_pr_registered_i_pts_show(struct config_item *item,
1898 char *page)
1899 {
1900 struct se_device *dev = pr_to_dev(item);
1901 const struct target_core_fabric_ops *tfo;
1902 struct t10_pr_registration *pr_reg;
1903 unsigned char buf[384];
1904 char i_buf[PR_REG_ISID_ID_LEN];
1905 ssize_t len = 0;
1906 int reg_count = 0;
1907
1908 len += sprintf(page+len, "SPC-3 PR Registrations:\n");
1909
1910 spin_lock(&dev->t10_pr.registration_lock);
1911 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
1912 pr_reg_list) {
1913
1914 memset(buf, 0, 384);
1915 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1916 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1917 core_pr_dump_initiator_port(pr_reg, i_buf,
1918 PR_REG_ISID_ID_LEN);
1919 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n",
1920 tfo->fabric_name,
1921 pr_reg->pr_reg_nacl->initiatorname, i_buf, pr_reg->pr_res_key,
1922 pr_reg->pr_res_generation);
1923
1924 if (len + strlen(buf) >= PAGE_SIZE)
1925 break;
1926
1927 len += sprintf(page+len, "%s", buf);
1928 reg_count++;
1929 }
1930 spin_unlock(&dev->t10_pr.registration_lock);
1931
1932 if (!reg_count)
1933 len += sprintf(page+len, "None\n");
1934
1935 return len;
1936 }
1937
target_pr_res_pr_type_show(struct config_item * item,char * page)1938 static ssize_t target_pr_res_pr_type_show(struct config_item *item, char *page)
1939 {
1940 struct se_device *dev = pr_to_dev(item);
1941 struct t10_pr_registration *pr_reg;
1942 ssize_t len = 0;
1943
1944 spin_lock(&dev->dev_reservation_lock);
1945 pr_reg = dev->dev_pr_res_holder;
1946 if (pr_reg) {
1947 len = sprintf(page, "SPC-3 Reservation Type: %s\n",
1948 core_scsi3_pr_dump_type(pr_reg->pr_res_type));
1949 } else {
1950 len = sprintf(page, "No SPC-3 Reservation holder\n");
1951 }
1952
1953 spin_unlock(&dev->dev_reservation_lock);
1954 return len;
1955 }
1956
target_pr_res_type_show(struct config_item * item,char * page)1957 static ssize_t target_pr_res_type_show(struct config_item *item, char *page)
1958 {
1959 struct se_device *dev = pr_to_dev(item);
1960
1961 if (!dev->dev_attrib.emulate_pr)
1962 return sprintf(page, "SPC_RESERVATIONS_DISABLED\n");
1963 if (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR)
1964 return sprintf(page, "SPC_PASSTHROUGH\n");
1965 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
1966 return sprintf(page, "SPC2_RESERVATIONS\n");
1967
1968 return sprintf(page, "SPC3_PERSISTENT_RESERVATIONS\n");
1969 }
1970
target_pr_res_aptpl_active_show(struct config_item * item,char * page)1971 static ssize_t target_pr_res_aptpl_active_show(struct config_item *item,
1972 char *page)
1973 {
1974 struct se_device *dev = pr_to_dev(item);
1975
1976 if (!dev->dev_attrib.emulate_pr ||
1977 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
1978 return 0;
1979
1980 return sprintf(page, "APTPL Bit Status: %s\n",
1981 (dev->t10_pr.pr_aptpl_active) ? "Activated" : "Disabled");
1982 }
1983
target_pr_res_aptpl_metadata_show(struct config_item * item,char * page)1984 static ssize_t target_pr_res_aptpl_metadata_show(struct config_item *item,
1985 char *page)
1986 {
1987 struct se_device *dev = pr_to_dev(item);
1988
1989 if (!dev->dev_attrib.emulate_pr ||
1990 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
1991 return 0;
1992
1993 return sprintf(page, "Ready to process PR APTPL metadata..\n");
1994 }
1995
1996 enum {
1997 Opt_initiator_fabric, Opt_initiator_node, Opt_initiator_sid,
1998 Opt_sa_res_key, Opt_res_holder, Opt_res_type, Opt_res_scope,
1999 Opt_res_all_tg_pt, Opt_mapped_lun, Opt_target_fabric,
2000 Opt_target_node, Opt_tpgt, Opt_port_rtpi, Opt_target_lun, Opt_err
2001 };
2002
2003 static match_table_t tokens = {
2004 {Opt_initiator_fabric, "initiator_fabric=%s"},
2005 {Opt_initiator_node, "initiator_node=%s"},
2006 {Opt_initiator_sid, "initiator_sid=%s"},
2007 {Opt_sa_res_key, "sa_res_key=%s"},
2008 {Opt_res_holder, "res_holder=%d"},
2009 {Opt_res_type, "res_type=%d"},
2010 {Opt_res_scope, "res_scope=%d"},
2011 {Opt_res_all_tg_pt, "res_all_tg_pt=%d"},
2012 {Opt_mapped_lun, "mapped_lun=%u"},
2013 {Opt_target_fabric, "target_fabric=%s"},
2014 {Opt_target_node, "target_node=%s"},
2015 {Opt_tpgt, "tpgt=%d"},
2016 {Opt_port_rtpi, "port_rtpi=%d"},
2017 {Opt_target_lun, "target_lun=%u"},
2018 {Opt_err, NULL}
2019 };
2020
target_pr_res_aptpl_metadata_store(struct config_item * item,const char * page,size_t count)2021 static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
2022 const char *page, size_t count)
2023 {
2024 struct se_device *dev = pr_to_dev(item);
2025 unsigned char *i_fabric = NULL, *i_port = NULL, *isid = NULL;
2026 unsigned char *t_fabric = NULL, *t_port = NULL;
2027 char *orig, *ptr, *opts;
2028 substring_t args[MAX_OPT_ARGS];
2029 unsigned long long tmp_ll;
2030 u64 sa_res_key = 0;
2031 u64 mapped_lun = 0, target_lun = 0;
2032 int ret = -1, res_holder = 0, all_tg_pt = 0, arg, token;
2033 u16 tpgt = 0;
2034 u8 type = 0;
2035
2036 if (!dev->dev_attrib.emulate_pr ||
2037 (dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_PGR))
2038 return count;
2039 if (dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS)
2040 return count;
2041
2042 if (dev->export_count) {
2043 pr_debug("Unable to process APTPL metadata while"
2044 " active fabric exports exist\n");
2045 return -EINVAL;
2046 }
2047
2048 opts = kstrdup(page, GFP_KERNEL);
2049 if (!opts)
2050 return -ENOMEM;
2051
2052 orig = opts;
2053 while ((ptr = strsep(&opts, ",\n")) != NULL) {
2054 if (!*ptr)
2055 continue;
2056
2057 token = match_token(ptr, tokens, args);
2058 switch (token) {
2059 case Opt_initiator_fabric:
2060 i_fabric = match_strdup(args);
2061 if (!i_fabric) {
2062 ret = -ENOMEM;
2063 goto out;
2064 }
2065 break;
2066 case Opt_initiator_node:
2067 i_port = match_strdup(args);
2068 if (!i_port) {
2069 ret = -ENOMEM;
2070 goto out;
2071 }
2072 if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) {
2073 pr_err("APTPL metadata initiator_node="
2074 " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
2075 PR_APTPL_MAX_IPORT_LEN);
2076 ret = -EINVAL;
2077 break;
2078 }
2079 break;
2080 case Opt_initiator_sid:
2081 isid = match_strdup(args);
2082 if (!isid) {
2083 ret = -ENOMEM;
2084 goto out;
2085 }
2086 if (strlen(isid) >= PR_REG_ISID_LEN) {
2087 pr_err("APTPL metadata initiator_isid"
2088 "= exceeds PR_REG_ISID_LEN: %d\n",
2089 PR_REG_ISID_LEN);
2090 ret = -EINVAL;
2091 break;
2092 }
2093 break;
2094 case Opt_sa_res_key:
2095 ret = match_u64(args, &tmp_ll);
2096 if (ret < 0) {
2097 pr_err("kstrtoull() failed for sa_res_key=\n");
2098 goto out;
2099 }
2100 sa_res_key = (u64)tmp_ll;
2101 break;
2102 /*
2103 * PR APTPL Metadata for Reservation
2104 */
2105 case Opt_res_holder:
2106 ret = match_int(args, &arg);
2107 if (ret)
2108 goto out;
2109 res_holder = arg;
2110 break;
2111 case Opt_res_type:
2112 ret = match_int(args, &arg);
2113 if (ret)
2114 goto out;
2115 type = (u8)arg;
2116 break;
2117 case Opt_res_scope:
2118 ret = match_int(args, &arg);
2119 if (ret)
2120 goto out;
2121 break;
2122 case Opt_res_all_tg_pt:
2123 ret = match_int(args, &arg);
2124 if (ret)
2125 goto out;
2126 all_tg_pt = (int)arg;
2127 break;
2128 case Opt_mapped_lun:
2129 ret = match_u64(args, &tmp_ll);
2130 if (ret)
2131 goto out;
2132 mapped_lun = (u64)tmp_ll;
2133 break;
2134 /*
2135 * PR APTPL Metadata for Target Port
2136 */
2137 case Opt_target_fabric:
2138 t_fabric = match_strdup(args);
2139 if (!t_fabric) {
2140 ret = -ENOMEM;
2141 goto out;
2142 }
2143 break;
2144 case Opt_target_node:
2145 t_port = match_strdup(args);
2146 if (!t_port) {
2147 ret = -ENOMEM;
2148 goto out;
2149 }
2150 if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) {
2151 pr_err("APTPL metadata target_node="
2152 " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
2153 PR_APTPL_MAX_TPORT_LEN);
2154 ret = -EINVAL;
2155 break;
2156 }
2157 break;
2158 case Opt_tpgt:
2159 ret = match_int(args, &arg);
2160 if (ret)
2161 goto out;
2162 tpgt = (u16)arg;
2163 break;
2164 case Opt_port_rtpi:
2165 ret = match_int(args, &arg);
2166 if (ret)
2167 goto out;
2168 break;
2169 case Opt_target_lun:
2170 ret = match_u64(args, &tmp_ll);
2171 if (ret)
2172 goto out;
2173 target_lun = (u64)tmp_ll;
2174 break;
2175 default:
2176 break;
2177 }
2178 }
2179
2180 if (!i_port || !t_port || !sa_res_key) {
2181 pr_err("Illegal parameters for APTPL registration\n");
2182 ret = -EINVAL;
2183 goto out;
2184 }
2185
2186 if (res_holder && !(type)) {
2187 pr_err("Illegal PR type: 0x%02x for reservation"
2188 " holder\n", type);
2189 ret = -EINVAL;
2190 goto out;
2191 }
2192
2193 ret = core_scsi3_alloc_aptpl_registration(&dev->t10_pr, sa_res_key,
2194 i_port, isid, mapped_lun, t_port, tpgt, target_lun,
2195 res_holder, all_tg_pt, type);
2196 out:
2197 kfree(i_fabric);
2198 kfree(i_port);
2199 kfree(isid);
2200 kfree(t_fabric);
2201 kfree(t_port);
2202 kfree(orig);
2203 return (ret == 0) ? count : ret;
2204 }
2205
2206
2207 CONFIGFS_ATTR_RO(target_pr_, res_holder);
2208 CONFIGFS_ATTR_RO(target_pr_, res_pr_all_tgt_pts);
2209 CONFIGFS_ATTR_RO(target_pr_, res_pr_generation);
2210 CONFIGFS_ATTR_RO(target_pr_, res_pr_holder_tg_port);
2211 CONFIGFS_ATTR_RO(target_pr_, res_pr_registered_i_pts);
2212 CONFIGFS_ATTR_RO(target_pr_, res_pr_type);
2213 CONFIGFS_ATTR_RO(target_pr_, res_type);
2214 CONFIGFS_ATTR_RO(target_pr_, res_aptpl_active);
2215 CONFIGFS_ATTR(target_pr_, res_aptpl_metadata);
2216
2217 static struct configfs_attribute *target_core_dev_pr_attrs[] = {
2218 &target_pr_attr_res_holder,
2219 &target_pr_attr_res_pr_all_tgt_pts,
2220 &target_pr_attr_res_pr_generation,
2221 &target_pr_attr_res_pr_holder_tg_port,
2222 &target_pr_attr_res_pr_registered_i_pts,
2223 &target_pr_attr_res_pr_type,
2224 &target_pr_attr_res_type,
2225 &target_pr_attr_res_aptpl_active,
2226 &target_pr_attr_res_aptpl_metadata,
2227 NULL,
2228 };
2229
2230 TB_CIT_SETUP(dev_pr, NULL, NULL, target_core_dev_pr_attrs);
2231
2232 /* End functions for struct config_item_type tb_dev_pr_cit */
2233
2234 /* Start functions for struct config_item_type tb_dev_cit */
2235
to_device(struct config_item * item)2236 static inline struct se_device *to_device(struct config_item *item)
2237 {
2238 return container_of(to_config_group(item), struct se_device, dev_group);
2239 }
2240
target_dev_info_show(struct config_item * item,char * page)2241 static ssize_t target_dev_info_show(struct config_item *item, char *page)
2242 {
2243 struct se_device *dev = to_device(item);
2244 int bl = 0;
2245 ssize_t read_bytes = 0;
2246
2247 transport_dump_dev_state(dev, page, &bl);
2248 read_bytes += bl;
2249 read_bytes += dev->transport->show_configfs_dev_params(dev,
2250 page+read_bytes);
2251 return read_bytes;
2252 }
2253
target_dev_control_store(struct config_item * item,const char * page,size_t count)2254 static ssize_t target_dev_control_store(struct config_item *item,
2255 const char *page, size_t count)
2256 {
2257 struct se_device *dev = to_device(item);
2258
2259 return dev->transport->set_configfs_dev_params(dev, page, count);
2260 }
2261
target_dev_alias_show(struct config_item * item,char * page)2262 static ssize_t target_dev_alias_show(struct config_item *item, char *page)
2263 {
2264 struct se_device *dev = to_device(item);
2265
2266 if (!(dev->dev_flags & DF_USING_ALIAS))
2267 return 0;
2268
2269 return snprintf(page, PAGE_SIZE, "%s\n", dev->dev_alias);
2270 }
2271
target_dev_alias_store(struct config_item * item,const char * page,size_t count)2272 static ssize_t target_dev_alias_store(struct config_item *item,
2273 const char *page, size_t count)
2274 {
2275 struct se_device *dev = to_device(item);
2276 struct se_hba *hba = dev->se_hba;
2277 ssize_t read_bytes;
2278
2279 if (count > (SE_DEV_ALIAS_LEN-1)) {
2280 pr_err("alias count: %d exceeds"
2281 " SE_DEV_ALIAS_LEN-1: %u\n", (int)count,
2282 SE_DEV_ALIAS_LEN-1);
2283 return -EINVAL;
2284 }
2285
2286 read_bytes = snprintf(&dev->dev_alias[0], SE_DEV_ALIAS_LEN, "%s", page);
2287 if (!read_bytes)
2288 return -EINVAL;
2289 if (dev->dev_alias[read_bytes - 1] == '\n')
2290 dev->dev_alias[read_bytes - 1] = '\0';
2291
2292 dev->dev_flags |= DF_USING_ALIAS;
2293
2294 pr_debug("Target_Core_ConfigFS: %s/%s set alias: %s\n",
2295 config_item_name(&hba->hba_group.cg_item),
2296 config_item_name(&dev->dev_group.cg_item),
2297 dev->dev_alias);
2298
2299 return read_bytes;
2300 }
2301
target_dev_udev_path_show(struct config_item * item,char * page)2302 static ssize_t target_dev_udev_path_show(struct config_item *item, char *page)
2303 {
2304 struct se_device *dev = to_device(item);
2305
2306 if (!(dev->dev_flags & DF_USING_UDEV_PATH))
2307 return 0;
2308
2309 return snprintf(page, PAGE_SIZE, "%s\n", dev->udev_path);
2310 }
2311
target_dev_udev_path_store(struct config_item * item,const char * page,size_t count)2312 static ssize_t target_dev_udev_path_store(struct config_item *item,
2313 const char *page, size_t count)
2314 {
2315 struct se_device *dev = to_device(item);
2316 struct se_hba *hba = dev->se_hba;
2317 ssize_t read_bytes;
2318
2319 if (count > (SE_UDEV_PATH_LEN-1)) {
2320 pr_err("udev_path count: %d exceeds"
2321 " SE_UDEV_PATH_LEN-1: %u\n", (int)count,
2322 SE_UDEV_PATH_LEN-1);
2323 return -EINVAL;
2324 }
2325
2326 read_bytes = snprintf(&dev->udev_path[0], SE_UDEV_PATH_LEN,
2327 "%s", page);
2328 if (!read_bytes)
2329 return -EINVAL;
2330 if (dev->udev_path[read_bytes - 1] == '\n')
2331 dev->udev_path[read_bytes - 1] = '\0';
2332
2333 dev->dev_flags |= DF_USING_UDEV_PATH;
2334
2335 pr_debug("Target_Core_ConfigFS: %s/%s set udev_path: %s\n",
2336 config_item_name(&hba->hba_group.cg_item),
2337 config_item_name(&dev->dev_group.cg_item),
2338 dev->udev_path);
2339
2340 return read_bytes;
2341 }
2342
target_dev_enable_show(struct config_item * item,char * page)2343 static ssize_t target_dev_enable_show(struct config_item *item, char *page)
2344 {
2345 struct se_device *dev = to_device(item);
2346
2347 return snprintf(page, PAGE_SIZE, "%d\n", target_dev_configured(dev));
2348 }
2349
target_dev_enable_store(struct config_item * item,const char * page,size_t count)2350 static ssize_t target_dev_enable_store(struct config_item *item,
2351 const char *page, size_t count)
2352 {
2353 struct se_device *dev = to_device(item);
2354 char *ptr;
2355 int ret;
2356
2357 ptr = strstr(page, "1");
2358 if (!ptr) {
2359 pr_err("For dev_enable ops, only valid value"
2360 " is \"1\"\n");
2361 return -EINVAL;
2362 }
2363
2364 ret = target_configure_device(dev);
2365 if (ret)
2366 return ret;
2367 return count;
2368 }
2369
target_dev_alua_lu_gp_show(struct config_item * item,char * page)2370 static ssize_t target_dev_alua_lu_gp_show(struct config_item *item, char *page)
2371 {
2372 struct se_device *dev = to_device(item);
2373 struct config_item *lu_ci;
2374 struct t10_alua_lu_gp *lu_gp;
2375 struct t10_alua_lu_gp_member *lu_gp_mem;
2376 ssize_t len = 0;
2377
2378 lu_gp_mem = dev->dev_alua_lu_gp_mem;
2379 if (!lu_gp_mem)
2380 return 0;
2381
2382 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
2383 lu_gp = lu_gp_mem->lu_gp;
2384 if (lu_gp) {
2385 lu_ci = &lu_gp->lu_gp_group.cg_item;
2386 len += sprintf(page, "LU Group Alias: %s\nLU Group ID: %hu\n",
2387 config_item_name(lu_ci), lu_gp->lu_gp_id);
2388 }
2389 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2390
2391 return len;
2392 }
2393
target_dev_alua_lu_gp_store(struct config_item * item,const char * page,size_t count)2394 static ssize_t target_dev_alua_lu_gp_store(struct config_item *item,
2395 const char *page, size_t count)
2396 {
2397 struct se_device *dev = to_device(item);
2398 struct se_hba *hba = dev->se_hba;
2399 struct t10_alua_lu_gp *lu_gp = NULL, *lu_gp_new = NULL;
2400 struct t10_alua_lu_gp_member *lu_gp_mem;
2401 unsigned char buf[LU_GROUP_NAME_BUF] = { };
2402 int move = 0;
2403
2404 lu_gp_mem = dev->dev_alua_lu_gp_mem;
2405 if (!lu_gp_mem)
2406 return count;
2407
2408 if (count > LU_GROUP_NAME_BUF) {
2409 pr_err("ALUA LU Group Alias too large!\n");
2410 return -EINVAL;
2411 }
2412 memcpy(buf, page, count);
2413 /*
2414 * Any ALUA logical unit alias besides "NULL" means we will be
2415 * making a new group association.
2416 */
2417 if (strcmp(strstrip(buf), "NULL")) {
2418 /*
2419 * core_alua_get_lu_gp_by_name() will increment reference to
2420 * struct t10_alua_lu_gp. This reference is released with
2421 * core_alua_get_lu_gp_by_name below().
2422 */
2423 lu_gp_new = core_alua_get_lu_gp_by_name(strstrip(buf));
2424 if (!lu_gp_new)
2425 return -ENODEV;
2426 }
2427
2428 spin_lock(&lu_gp_mem->lu_gp_mem_lock);
2429 lu_gp = lu_gp_mem->lu_gp;
2430 if (lu_gp) {
2431 /*
2432 * Clearing an existing lu_gp association, and replacing
2433 * with NULL
2434 */
2435 if (!lu_gp_new) {
2436 pr_debug("Target_Core_ConfigFS: Releasing %s/%s"
2437 " from ALUA LU Group: core/alua/lu_gps/%s, ID:"
2438 " %hu\n",
2439 config_item_name(&hba->hba_group.cg_item),
2440 config_item_name(&dev->dev_group.cg_item),
2441 config_item_name(&lu_gp->lu_gp_group.cg_item),
2442 lu_gp->lu_gp_id);
2443
2444 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
2445 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2446
2447 return count;
2448 }
2449 /*
2450 * Removing existing association of lu_gp_mem with lu_gp
2451 */
2452 __core_alua_drop_lu_gp_mem(lu_gp_mem, lu_gp);
2453 move = 1;
2454 }
2455 /*
2456 * Associate lu_gp_mem with lu_gp_new.
2457 */
2458 __core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new);
2459 spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
2460
2461 pr_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:"
2462 " core/alua/lu_gps/%s, ID: %hu\n",
2463 (move) ? "Moving" : "Adding",
2464 config_item_name(&hba->hba_group.cg_item),
2465 config_item_name(&dev->dev_group.cg_item),
2466 config_item_name(&lu_gp_new->lu_gp_group.cg_item),
2467 lu_gp_new->lu_gp_id);
2468
2469 core_alua_put_lu_gp_from_name(lu_gp_new);
2470 return count;
2471 }
2472
target_dev_lba_map_show(struct config_item * item,char * page)2473 static ssize_t target_dev_lba_map_show(struct config_item *item, char *page)
2474 {
2475 struct se_device *dev = to_device(item);
2476 struct t10_alua_lba_map *map;
2477 struct t10_alua_lba_map_member *mem;
2478 char *b = page;
2479 int bl = 0;
2480 char state;
2481
2482 spin_lock(&dev->t10_alua.lba_map_lock);
2483 if (!list_empty(&dev->t10_alua.lba_map_list))
2484 bl += sprintf(b + bl, "%u %u\n",
2485 dev->t10_alua.lba_map_segment_size,
2486 dev->t10_alua.lba_map_segment_multiplier);
2487 list_for_each_entry(map, &dev->t10_alua.lba_map_list, lba_map_list) {
2488 bl += sprintf(b + bl, "%llu %llu",
2489 map->lba_map_first_lba, map->lba_map_last_lba);
2490 list_for_each_entry(mem, &map->lba_map_mem_list,
2491 lba_map_mem_list) {
2492 switch (mem->lba_map_mem_alua_state) {
2493 case ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED:
2494 state = 'O';
2495 break;
2496 case ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED:
2497 state = 'A';
2498 break;
2499 case ALUA_ACCESS_STATE_STANDBY:
2500 state = 'S';
2501 break;
2502 case ALUA_ACCESS_STATE_UNAVAILABLE:
2503 state = 'U';
2504 break;
2505 default:
2506 state = '.';
2507 break;
2508 }
2509 bl += sprintf(b + bl, " %d:%c",
2510 mem->lba_map_mem_alua_pg_id, state);
2511 }
2512 bl += sprintf(b + bl, "\n");
2513 }
2514 spin_unlock(&dev->t10_alua.lba_map_lock);
2515 return bl;
2516 }
2517
target_dev_lba_map_store(struct config_item * item,const char * page,size_t count)2518 static ssize_t target_dev_lba_map_store(struct config_item *item,
2519 const char *page, size_t count)
2520 {
2521 struct se_device *dev = to_device(item);
2522 struct t10_alua_lba_map *lba_map = NULL;
2523 struct list_head lba_list;
2524 char *map_entries, *orig, *ptr;
2525 char state;
2526 int pg_num = -1, pg;
2527 int ret = 0, num = 0, pg_id, alua_state;
2528 unsigned long start_lba = -1, end_lba = -1;
2529 unsigned long segment_size = -1, segment_mult = -1;
2530
2531 orig = map_entries = kstrdup(page, GFP_KERNEL);
2532 if (!map_entries)
2533 return -ENOMEM;
2534
2535 INIT_LIST_HEAD(&lba_list);
2536 while ((ptr = strsep(&map_entries, "\n")) != NULL) {
2537 if (!*ptr)
2538 continue;
2539
2540 if (num == 0) {
2541 if (sscanf(ptr, "%lu %lu\n",
2542 &segment_size, &segment_mult) != 2) {
2543 pr_err("Invalid line %d\n", num);
2544 ret = -EINVAL;
2545 break;
2546 }
2547 num++;
2548 continue;
2549 }
2550 if (sscanf(ptr, "%lu %lu", &start_lba, &end_lba) != 2) {
2551 pr_err("Invalid line %d\n", num);
2552 ret = -EINVAL;
2553 break;
2554 }
2555 ptr = strchr(ptr, ' ');
2556 if (!ptr) {
2557 pr_err("Invalid line %d, missing end lba\n", num);
2558 ret = -EINVAL;
2559 break;
2560 }
2561 ptr++;
2562 ptr = strchr(ptr, ' ');
2563 if (!ptr) {
2564 pr_err("Invalid line %d, missing state definitions\n",
2565 num);
2566 ret = -EINVAL;
2567 break;
2568 }
2569 ptr++;
2570 lba_map = core_alua_allocate_lba_map(&lba_list,
2571 start_lba, end_lba);
2572 if (IS_ERR(lba_map)) {
2573 ret = PTR_ERR(lba_map);
2574 break;
2575 }
2576 pg = 0;
2577 while (sscanf(ptr, "%d:%c", &pg_id, &state) == 2) {
2578 switch (state) {
2579 case 'O':
2580 alua_state = ALUA_ACCESS_STATE_ACTIVE_OPTIMIZED;
2581 break;
2582 case 'A':
2583 alua_state = ALUA_ACCESS_STATE_ACTIVE_NON_OPTIMIZED;
2584 break;
2585 case 'S':
2586 alua_state = ALUA_ACCESS_STATE_STANDBY;
2587 break;
2588 case 'U':
2589 alua_state = ALUA_ACCESS_STATE_UNAVAILABLE;
2590 break;
2591 default:
2592 pr_err("Invalid ALUA state '%c'\n", state);
2593 ret = -EINVAL;
2594 goto out;
2595 }
2596
2597 ret = core_alua_allocate_lba_map_mem(lba_map,
2598 pg_id, alua_state);
2599 if (ret) {
2600 pr_err("Invalid target descriptor %d:%c "
2601 "at line %d\n",
2602 pg_id, state, num);
2603 break;
2604 }
2605 pg++;
2606 ptr = strchr(ptr, ' ');
2607 if (ptr)
2608 ptr++;
2609 else
2610 break;
2611 }
2612 if (pg_num == -1)
2613 pg_num = pg;
2614 else if (pg != pg_num) {
2615 pr_err("Only %d from %d port groups definitions "
2616 "at line %d\n", pg, pg_num, num);
2617 ret = -EINVAL;
2618 break;
2619 }
2620 num++;
2621 }
2622 out:
2623 if (ret) {
2624 core_alua_free_lba_map(&lba_list);
2625 count = ret;
2626 } else
2627 core_alua_set_lba_map(dev, &lba_list,
2628 segment_size, segment_mult);
2629 kfree(orig);
2630 return count;
2631 }
2632
2633 CONFIGFS_ATTR_RO(target_dev_, info);
2634 CONFIGFS_ATTR_WO(target_dev_, control);
2635 CONFIGFS_ATTR(target_dev_, alias);
2636 CONFIGFS_ATTR(target_dev_, udev_path);
2637 CONFIGFS_ATTR(target_dev_, enable);
2638 CONFIGFS_ATTR(target_dev_, alua_lu_gp);
2639 CONFIGFS_ATTR(target_dev_, lba_map);
2640
2641 static struct configfs_attribute *target_core_dev_attrs[] = {
2642 &target_dev_attr_info,
2643 &target_dev_attr_control,
2644 &target_dev_attr_alias,
2645 &target_dev_attr_udev_path,
2646 &target_dev_attr_enable,
2647 &target_dev_attr_alua_lu_gp,
2648 &target_dev_attr_lba_map,
2649 NULL,
2650 };
2651
target_core_dev_release(struct config_item * item)2652 static void target_core_dev_release(struct config_item *item)
2653 {
2654 struct config_group *dev_cg = to_config_group(item);
2655 struct se_device *dev =
2656 container_of(dev_cg, struct se_device, dev_group);
2657
2658 target_free_device(dev);
2659 }
2660
2661 /*
2662 * Used in target_core_fabric_configfs.c to verify valid se_device symlink
2663 * within target_fabric_port_link()
2664 */
2665 struct configfs_item_operations target_core_dev_item_ops = {
2666 .release = target_core_dev_release,
2667 };
2668
2669 TB_CIT_SETUP(dev, &target_core_dev_item_ops, NULL, target_core_dev_attrs);
2670
2671 /* End functions for struct config_item_type tb_dev_cit */
2672
2673 /* Start functions for struct config_item_type target_core_alua_lu_gp_cit */
2674
to_lu_gp(struct config_item * item)2675 static inline struct t10_alua_lu_gp *to_lu_gp(struct config_item *item)
2676 {
2677 return container_of(to_config_group(item), struct t10_alua_lu_gp,
2678 lu_gp_group);
2679 }
2680
target_lu_gp_lu_gp_id_show(struct config_item * item,char * page)2681 static ssize_t target_lu_gp_lu_gp_id_show(struct config_item *item, char *page)
2682 {
2683 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2684
2685 if (!lu_gp->lu_gp_valid_id)
2686 return 0;
2687 return sprintf(page, "%hu\n", lu_gp->lu_gp_id);
2688 }
2689
target_lu_gp_lu_gp_id_store(struct config_item * item,const char * page,size_t count)2690 static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item,
2691 const char *page, size_t count)
2692 {
2693 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2694 struct config_group *alua_lu_gp_cg = &lu_gp->lu_gp_group;
2695 unsigned long lu_gp_id;
2696 int ret;
2697
2698 ret = kstrtoul(page, 0, &lu_gp_id);
2699 if (ret < 0) {
2700 pr_err("kstrtoul() returned %d for"
2701 " lu_gp_id\n", ret);
2702 return ret;
2703 }
2704 if (lu_gp_id > 0x0000ffff) {
2705 pr_err("ALUA lu_gp_id: %lu exceeds maximum:"
2706 " 0x0000ffff\n", lu_gp_id);
2707 return -EINVAL;
2708 }
2709
2710 ret = core_alua_set_lu_gp_id(lu_gp, (u16)lu_gp_id);
2711 if (ret < 0)
2712 return -EINVAL;
2713
2714 pr_debug("Target_Core_ConfigFS: Set ALUA Logical Unit"
2715 " Group: core/alua/lu_gps/%s to ID: %hu\n",
2716 config_item_name(&alua_lu_gp_cg->cg_item),
2717 lu_gp->lu_gp_id);
2718
2719 return count;
2720 }
2721
target_lu_gp_members_show(struct config_item * item,char * page)2722 static ssize_t target_lu_gp_members_show(struct config_item *item, char *page)
2723 {
2724 struct t10_alua_lu_gp *lu_gp = to_lu_gp(item);
2725 struct se_device *dev;
2726 struct se_hba *hba;
2727 struct t10_alua_lu_gp_member *lu_gp_mem;
2728 ssize_t len = 0, cur_len;
2729 unsigned char buf[LU_GROUP_NAME_BUF] = { };
2730
2731 spin_lock(&lu_gp->lu_gp_lock);
2732 list_for_each_entry(lu_gp_mem, &lu_gp->lu_gp_mem_list, lu_gp_mem_list) {
2733 dev = lu_gp_mem->lu_gp_mem_dev;
2734 hba = dev->se_hba;
2735
2736 cur_len = snprintf(buf, LU_GROUP_NAME_BUF, "%s/%s\n",
2737 config_item_name(&hba->hba_group.cg_item),
2738 config_item_name(&dev->dev_group.cg_item));
2739 cur_len++; /* Extra byte for NULL terminator */
2740
2741 if ((cur_len + len) > PAGE_SIZE) {
2742 pr_warn("Ran out of lu_gp_show_attr"
2743 "_members buffer\n");
2744 break;
2745 }
2746 memcpy(page+len, buf, cur_len);
2747 len += cur_len;
2748 }
2749 spin_unlock(&lu_gp->lu_gp_lock);
2750
2751 return len;
2752 }
2753
2754 CONFIGFS_ATTR(target_lu_gp_, lu_gp_id);
2755 CONFIGFS_ATTR_RO(target_lu_gp_, members);
2756
2757 static struct configfs_attribute *target_core_alua_lu_gp_attrs[] = {
2758 &target_lu_gp_attr_lu_gp_id,
2759 &target_lu_gp_attr_members,
2760 NULL,
2761 };
2762
target_core_alua_lu_gp_release(struct config_item * item)2763 static void target_core_alua_lu_gp_release(struct config_item *item)
2764 {
2765 struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2766 struct t10_alua_lu_gp, lu_gp_group);
2767
2768 core_alua_free_lu_gp(lu_gp);
2769 }
2770
2771 static struct configfs_item_operations target_core_alua_lu_gp_ops = {
2772 .release = target_core_alua_lu_gp_release,
2773 };
2774
2775 static const struct config_item_type target_core_alua_lu_gp_cit = {
2776 .ct_item_ops = &target_core_alua_lu_gp_ops,
2777 .ct_attrs = target_core_alua_lu_gp_attrs,
2778 .ct_owner = THIS_MODULE,
2779 };
2780
2781 /* End functions for struct config_item_type target_core_alua_lu_gp_cit */
2782
2783 /* Start functions for struct config_item_type target_core_alua_lu_gps_cit */
2784
target_core_alua_create_lu_gp(struct config_group * group,const char * name)2785 static struct config_group *target_core_alua_create_lu_gp(
2786 struct config_group *group,
2787 const char *name)
2788 {
2789 struct t10_alua_lu_gp *lu_gp;
2790 struct config_group *alua_lu_gp_cg = NULL;
2791 struct config_item *alua_lu_gp_ci = NULL;
2792
2793 lu_gp = core_alua_allocate_lu_gp(name, 0);
2794 if (IS_ERR(lu_gp))
2795 return NULL;
2796
2797 alua_lu_gp_cg = &lu_gp->lu_gp_group;
2798 alua_lu_gp_ci = &alua_lu_gp_cg->cg_item;
2799
2800 config_group_init_type_name(alua_lu_gp_cg, name,
2801 &target_core_alua_lu_gp_cit);
2802
2803 pr_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit"
2804 " Group: core/alua/lu_gps/%s\n",
2805 config_item_name(alua_lu_gp_ci));
2806
2807 return alua_lu_gp_cg;
2808
2809 }
2810
target_core_alua_drop_lu_gp(struct config_group * group,struct config_item * item)2811 static void target_core_alua_drop_lu_gp(
2812 struct config_group *group,
2813 struct config_item *item)
2814 {
2815 struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
2816 struct t10_alua_lu_gp, lu_gp_group);
2817
2818 pr_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit"
2819 " Group: core/alua/lu_gps/%s, ID: %hu\n",
2820 config_item_name(item), lu_gp->lu_gp_id);
2821 /*
2822 * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release()
2823 * -> target_core_alua_lu_gp_release()
2824 */
2825 config_item_put(item);
2826 }
2827
2828 static struct configfs_group_operations target_core_alua_lu_gps_group_ops = {
2829 .make_group = &target_core_alua_create_lu_gp,
2830 .drop_item = &target_core_alua_drop_lu_gp,
2831 };
2832
2833 static const struct config_item_type target_core_alua_lu_gps_cit = {
2834 .ct_item_ops = NULL,
2835 .ct_group_ops = &target_core_alua_lu_gps_group_ops,
2836 .ct_owner = THIS_MODULE,
2837 };
2838
2839 /* End functions for struct config_item_type target_core_alua_lu_gps_cit */
2840
2841 /* Start functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
2842
to_tg_pt_gp(struct config_item * item)2843 static inline struct t10_alua_tg_pt_gp *to_tg_pt_gp(struct config_item *item)
2844 {
2845 return container_of(to_config_group(item), struct t10_alua_tg_pt_gp,
2846 tg_pt_gp_group);
2847 }
2848
target_tg_pt_gp_alua_access_state_show(struct config_item * item,char * page)2849 static ssize_t target_tg_pt_gp_alua_access_state_show(struct config_item *item,
2850 char *page)
2851 {
2852 return sprintf(page, "%d\n",
2853 to_tg_pt_gp(item)->tg_pt_gp_alua_access_state);
2854 }
2855
target_tg_pt_gp_alua_access_state_store(struct config_item * item,const char * page,size_t count)2856 static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item,
2857 const char *page, size_t count)
2858 {
2859 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2860 struct se_device *dev = tg_pt_gp->tg_pt_gp_dev;
2861 unsigned long tmp;
2862 int new_state, ret;
2863
2864 if (!tg_pt_gp->tg_pt_gp_valid_id) {
2865 pr_err("Unable to do implicit ALUA on invalid tg_pt_gp ID\n");
2866 return -EINVAL;
2867 }
2868 if (!target_dev_configured(dev)) {
2869 pr_err("Unable to set alua_access_state while device is"
2870 " not configured\n");
2871 return -ENODEV;
2872 }
2873
2874 ret = kstrtoul(page, 0, &tmp);
2875 if (ret < 0) {
2876 pr_err("Unable to extract new ALUA access state from"
2877 " %s\n", page);
2878 return ret;
2879 }
2880 new_state = (int)tmp;
2881
2882 if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)) {
2883 pr_err("Unable to process implicit configfs ALUA"
2884 " transition while TPGS_IMPLICIT_ALUA is disabled\n");
2885 return -EINVAL;
2886 }
2887 if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA &&
2888 new_state == ALUA_ACCESS_STATE_LBA_DEPENDENT) {
2889 /* LBA DEPENDENT is only allowed with implicit ALUA */
2890 pr_err("Unable to process implicit configfs ALUA transition"
2891 " while explicit ALUA management is enabled\n");
2892 return -EINVAL;
2893 }
2894
2895 ret = core_alua_do_port_transition(tg_pt_gp, dev,
2896 NULL, NULL, new_state, 0);
2897 return (!ret) ? count : -EINVAL;
2898 }
2899
target_tg_pt_gp_alua_access_status_show(struct config_item * item,char * page)2900 static ssize_t target_tg_pt_gp_alua_access_status_show(struct config_item *item,
2901 char *page)
2902 {
2903 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2904 return sprintf(page, "%s\n",
2905 core_alua_dump_status(tg_pt_gp->tg_pt_gp_alua_access_status));
2906 }
2907
target_tg_pt_gp_alua_access_status_store(struct config_item * item,const char * page,size_t count)2908 static ssize_t target_tg_pt_gp_alua_access_status_store(
2909 struct config_item *item, const char *page, size_t count)
2910 {
2911 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
2912 unsigned long tmp;
2913 int new_status, ret;
2914
2915 if (!tg_pt_gp->tg_pt_gp_valid_id) {
2916 pr_err("Unable to set ALUA access status on invalid tg_pt_gp ID\n");
2917 return -EINVAL;
2918 }
2919
2920 ret = kstrtoul(page, 0, &tmp);
2921 if (ret < 0) {
2922 pr_err("Unable to extract new ALUA access status"
2923 " from %s\n", page);
2924 return ret;
2925 }
2926 new_status = (int)tmp;
2927
2928 if ((new_status != ALUA_STATUS_NONE) &&
2929 (new_status != ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG) &&
2930 (new_status != ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA)) {
2931 pr_err("Illegal ALUA access status: 0x%02x\n",
2932 new_status);
2933 return -EINVAL;
2934 }
2935
2936 tg_pt_gp->tg_pt_gp_alua_access_status = new_status;
2937 return count;
2938 }
2939
target_tg_pt_gp_alua_access_type_show(struct config_item * item,char * page)2940 static ssize_t target_tg_pt_gp_alua_access_type_show(struct config_item *item,
2941 char *page)
2942 {
2943 return core_alua_show_access_type(to_tg_pt_gp(item), page);
2944 }
2945
target_tg_pt_gp_alua_access_type_store(struct config_item * item,const char * page,size_t count)2946 static ssize_t target_tg_pt_gp_alua_access_type_store(struct config_item *item,
2947 const char *page, size_t count)
2948 {
2949 return core_alua_store_access_type(to_tg_pt_gp(item), page, count);
2950 }
2951
2952 #define ALUA_SUPPORTED_STATE_ATTR(_name, _bit) \
2953 static ssize_t target_tg_pt_gp_alua_support_##_name##_show( \
2954 struct config_item *item, char *p) \
2955 { \
2956 struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \
2957 return sprintf(p, "%d\n", \
2958 !!(t->tg_pt_gp_alua_supported_states & _bit)); \
2959 } \
2960 \
2961 static ssize_t target_tg_pt_gp_alua_support_##_name##_store( \
2962 struct config_item *item, const char *p, size_t c) \
2963 { \
2964 struct t10_alua_tg_pt_gp *t = to_tg_pt_gp(item); \
2965 unsigned long tmp; \
2966 int ret; \
2967 \
2968 if (!t->tg_pt_gp_valid_id) { \
2969 pr_err("Unable to set " #_name " ALUA state on invalid tg_pt_gp ID\n"); \
2970 return -EINVAL; \
2971 } \
2972 \
2973 ret = kstrtoul(p, 0, &tmp); \
2974 if (ret < 0) { \
2975 pr_err("Invalid value '%s', must be '0' or '1'\n", p); \
2976 return -EINVAL; \
2977 } \
2978 if (tmp > 1) { \
2979 pr_err("Invalid value '%ld', must be '0' or '1'\n", tmp); \
2980 return -EINVAL; \
2981 } \
2982 if (tmp) \
2983 t->tg_pt_gp_alua_supported_states |= _bit; \
2984 else \
2985 t->tg_pt_gp_alua_supported_states &= ~_bit; \
2986 \
2987 return c; \
2988 }
2989
2990 ALUA_SUPPORTED_STATE_ATTR(transitioning, ALUA_T_SUP);
2991 ALUA_SUPPORTED_STATE_ATTR(offline, ALUA_O_SUP);
2992 ALUA_SUPPORTED_STATE_ATTR(lba_dependent, ALUA_LBD_SUP);
2993 ALUA_SUPPORTED_STATE_ATTR(unavailable, ALUA_U_SUP);
2994 ALUA_SUPPORTED_STATE_ATTR(standby, ALUA_S_SUP);
2995 ALUA_SUPPORTED_STATE_ATTR(active_optimized, ALUA_AO_SUP);
2996 ALUA_SUPPORTED_STATE_ATTR(active_nonoptimized, ALUA_AN_SUP);
2997
target_tg_pt_gp_alua_write_metadata_show(struct config_item * item,char * page)2998 static ssize_t target_tg_pt_gp_alua_write_metadata_show(
2999 struct config_item *item, char *page)
3000 {
3001 return sprintf(page, "%d\n",
3002 to_tg_pt_gp(item)->tg_pt_gp_write_metadata);
3003 }
3004
target_tg_pt_gp_alua_write_metadata_store(struct config_item * item,const char * page,size_t count)3005 static ssize_t target_tg_pt_gp_alua_write_metadata_store(
3006 struct config_item *item, const char *page, size_t count)
3007 {
3008 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3009 unsigned long tmp;
3010 int ret;
3011
3012 ret = kstrtoul(page, 0, &tmp);
3013 if (ret < 0) {
3014 pr_err("Unable to extract alua_write_metadata\n");
3015 return ret;
3016 }
3017
3018 if ((tmp != 0) && (tmp != 1)) {
3019 pr_err("Illegal value for alua_write_metadata:"
3020 " %lu\n", tmp);
3021 return -EINVAL;
3022 }
3023 tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp;
3024
3025 return count;
3026 }
3027
target_tg_pt_gp_nonop_delay_msecs_show(struct config_item * item,char * page)3028 static ssize_t target_tg_pt_gp_nonop_delay_msecs_show(struct config_item *item,
3029 char *page)
3030 {
3031 return core_alua_show_nonop_delay_msecs(to_tg_pt_gp(item), page);
3032 }
3033
target_tg_pt_gp_nonop_delay_msecs_store(struct config_item * item,const char * page,size_t count)3034 static ssize_t target_tg_pt_gp_nonop_delay_msecs_store(struct config_item *item,
3035 const char *page, size_t count)
3036 {
3037 return core_alua_store_nonop_delay_msecs(to_tg_pt_gp(item), page,
3038 count);
3039 }
3040
target_tg_pt_gp_trans_delay_msecs_show(struct config_item * item,char * page)3041 static ssize_t target_tg_pt_gp_trans_delay_msecs_show(struct config_item *item,
3042 char *page)
3043 {
3044 return core_alua_show_trans_delay_msecs(to_tg_pt_gp(item), page);
3045 }
3046
target_tg_pt_gp_trans_delay_msecs_store(struct config_item * item,const char * page,size_t count)3047 static ssize_t target_tg_pt_gp_trans_delay_msecs_store(struct config_item *item,
3048 const char *page, size_t count)
3049 {
3050 return core_alua_store_trans_delay_msecs(to_tg_pt_gp(item), page,
3051 count);
3052 }
3053
target_tg_pt_gp_implicit_trans_secs_show(struct config_item * item,char * page)3054 static ssize_t target_tg_pt_gp_implicit_trans_secs_show(
3055 struct config_item *item, char *page)
3056 {
3057 return core_alua_show_implicit_trans_secs(to_tg_pt_gp(item), page);
3058 }
3059
target_tg_pt_gp_implicit_trans_secs_store(struct config_item * item,const char * page,size_t count)3060 static ssize_t target_tg_pt_gp_implicit_trans_secs_store(
3061 struct config_item *item, const char *page, size_t count)
3062 {
3063 return core_alua_store_implicit_trans_secs(to_tg_pt_gp(item), page,
3064 count);
3065 }
3066
target_tg_pt_gp_preferred_show(struct config_item * item,char * page)3067 static ssize_t target_tg_pt_gp_preferred_show(struct config_item *item,
3068 char *page)
3069 {
3070 return core_alua_show_preferred_bit(to_tg_pt_gp(item), page);
3071 }
3072
target_tg_pt_gp_preferred_store(struct config_item * item,const char * page,size_t count)3073 static ssize_t target_tg_pt_gp_preferred_store(struct config_item *item,
3074 const char *page, size_t count)
3075 {
3076 return core_alua_store_preferred_bit(to_tg_pt_gp(item), page, count);
3077 }
3078
target_tg_pt_gp_tg_pt_gp_id_show(struct config_item * item,char * page)3079 static ssize_t target_tg_pt_gp_tg_pt_gp_id_show(struct config_item *item,
3080 char *page)
3081 {
3082 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3083
3084 if (!tg_pt_gp->tg_pt_gp_valid_id)
3085 return 0;
3086 return sprintf(page, "%hu\n", tg_pt_gp->tg_pt_gp_id);
3087 }
3088
target_tg_pt_gp_tg_pt_gp_id_store(struct config_item * item,const char * page,size_t count)3089 static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item,
3090 const char *page, size_t count)
3091 {
3092 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3093 struct config_group *alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
3094 unsigned long tg_pt_gp_id;
3095 int ret;
3096
3097 ret = kstrtoul(page, 0, &tg_pt_gp_id);
3098 if (ret < 0) {
3099 pr_err("ALUA tg_pt_gp_id: invalid value '%s' for tg_pt_gp_id\n",
3100 page);
3101 return ret;
3102 }
3103 if (tg_pt_gp_id > 0x0000ffff) {
3104 pr_err("ALUA tg_pt_gp_id: %lu exceeds maximum: 0x0000ffff\n",
3105 tg_pt_gp_id);
3106 return -EINVAL;
3107 }
3108
3109 ret = core_alua_set_tg_pt_gp_id(tg_pt_gp, (u16)tg_pt_gp_id);
3110 if (ret < 0)
3111 return -EINVAL;
3112
3113 pr_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: "
3114 "core/alua/tg_pt_gps/%s to ID: %hu\n",
3115 config_item_name(&alua_tg_pt_gp_cg->cg_item),
3116 tg_pt_gp->tg_pt_gp_id);
3117
3118 return count;
3119 }
3120
target_tg_pt_gp_members_show(struct config_item * item,char * page)3121 static ssize_t target_tg_pt_gp_members_show(struct config_item *item,
3122 char *page)
3123 {
3124 struct t10_alua_tg_pt_gp *tg_pt_gp = to_tg_pt_gp(item);
3125 struct se_lun *lun;
3126 ssize_t len = 0, cur_len;
3127 unsigned char buf[TG_PT_GROUP_NAME_BUF] = { };
3128
3129 spin_lock(&tg_pt_gp->tg_pt_gp_lock);
3130 list_for_each_entry(lun, &tg_pt_gp->tg_pt_gp_lun_list,
3131 lun_tg_pt_gp_link) {
3132 struct se_portal_group *tpg = lun->lun_tpg;
3133
3134 cur_len = snprintf(buf, TG_PT_GROUP_NAME_BUF, "%s/%s/tpgt_%hu"
3135 "/%s\n", tpg->se_tpg_tfo->fabric_name,
3136 tpg->se_tpg_tfo->tpg_get_wwn(tpg),
3137 tpg->se_tpg_tfo->tpg_get_tag(tpg),
3138 config_item_name(&lun->lun_group.cg_item));
3139 cur_len++; /* Extra byte for NULL terminator */
3140
3141 if ((cur_len + len) > PAGE_SIZE) {
3142 pr_warn("Ran out of lu_gp_show_attr"
3143 "_members buffer\n");
3144 break;
3145 }
3146 memcpy(page+len, buf, cur_len);
3147 len += cur_len;
3148 }
3149 spin_unlock(&tg_pt_gp->tg_pt_gp_lock);
3150
3151 return len;
3152 }
3153
3154 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_state);
3155 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_status);
3156 CONFIGFS_ATTR(target_tg_pt_gp_, alua_access_type);
3157 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_transitioning);
3158 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_offline);
3159 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_lba_dependent);
3160 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_unavailable);
3161 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_standby);
3162 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_optimized);
3163 CONFIGFS_ATTR(target_tg_pt_gp_, alua_support_active_nonoptimized);
3164 CONFIGFS_ATTR(target_tg_pt_gp_, alua_write_metadata);
3165 CONFIGFS_ATTR(target_tg_pt_gp_, nonop_delay_msecs);
3166 CONFIGFS_ATTR(target_tg_pt_gp_, trans_delay_msecs);
3167 CONFIGFS_ATTR(target_tg_pt_gp_, implicit_trans_secs);
3168 CONFIGFS_ATTR(target_tg_pt_gp_, preferred);
3169 CONFIGFS_ATTR(target_tg_pt_gp_, tg_pt_gp_id);
3170 CONFIGFS_ATTR_RO(target_tg_pt_gp_, members);
3171
3172 static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = {
3173 &target_tg_pt_gp_attr_alua_access_state,
3174 &target_tg_pt_gp_attr_alua_access_status,
3175 &target_tg_pt_gp_attr_alua_access_type,
3176 &target_tg_pt_gp_attr_alua_support_transitioning,
3177 &target_tg_pt_gp_attr_alua_support_offline,
3178 &target_tg_pt_gp_attr_alua_support_lba_dependent,
3179 &target_tg_pt_gp_attr_alua_support_unavailable,
3180 &target_tg_pt_gp_attr_alua_support_standby,
3181 &target_tg_pt_gp_attr_alua_support_active_nonoptimized,
3182 &target_tg_pt_gp_attr_alua_support_active_optimized,
3183 &target_tg_pt_gp_attr_alua_write_metadata,
3184 &target_tg_pt_gp_attr_nonop_delay_msecs,
3185 &target_tg_pt_gp_attr_trans_delay_msecs,
3186 &target_tg_pt_gp_attr_implicit_trans_secs,
3187 &target_tg_pt_gp_attr_preferred,
3188 &target_tg_pt_gp_attr_tg_pt_gp_id,
3189 &target_tg_pt_gp_attr_members,
3190 NULL,
3191 };
3192
target_core_alua_tg_pt_gp_release(struct config_item * item)3193 static void target_core_alua_tg_pt_gp_release(struct config_item *item)
3194 {
3195 struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
3196 struct t10_alua_tg_pt_gp, tg_pt_gp_group);
3197
3198 core_alua_free_tg_pt_gp(tg_pt_gp);
3199 }
3200
3201 static struct configfs_item_operations target_core_alua_tg_pt_gp_ops = {
3202 .release = target_core_alua_tg_pt_gp_release,
3203 };
3204
3205 static const struct config_item_type target_core_alua_tg_pt_gp_cit = {
3206 .ct_item_ops = &target_core_alua_tg_pt_gp_ops,
3207 .ct_attrs = target_core_alua_tg_pt_gp_attrs,
3208 .ct_owner = THIS_MODULE,
3209 };
3210
3211 /* End functions for struct config_item_type target_core_alua_tg_pt_gp_cit */
3212
3213 /* Start functions for struct config_item_type tb_alua_tg_pt_gps_cit */
3214
target_core_alua_create_tg_pt_gp(struct config_group * group,const char * name)3215 static struct config_group *target_core_alua_create_tg_pt_gp(
3216 struct config_group *group,
3217 const char *name)
3218 {
3219 struct t10_alua *alua = container_of(group, struct t10_alua,
3220 alua_tg_pt_gps_group);
3221 struct t10_alua_tg_pt_gp *tg_pt_gp;
3222 struct config_group *alua_tg_pt_gp_cg = NULL;
3223 struct config_item *alua_tg_pt_gp_ci = NULL;
3224
3225 tg_pt_gp = core_alua_allocate_tg_pt_gp(alua->t10_dev, name, 0);
3226 if (!tg_pt_gp)
3227 return NULL;
3228
3229 alua_tg_pt_gp_cg = &tg_pt_gp->tg_pt_gp_group;
3230 alua_tg_pt_gp_ci = &alua_tg_pt_gp_cg->cg_item;
3231
3232 config_group_init_type_name(alua_tg_pt_gp_cg, name,
3233 &target_core_alua_tg_pt_gp_cit);
3234
3235 pr_debug("Target_Core_ConfigFS: Allocated ALUA Target Port"
3236 " Group: alua/tg_pt_gps/%s\n",
3237 config_item_name(alua_tg_pt_gp_ci));
3238
3239 return alua_tg_pt_gp_cg;
3240 }
3241
target_core_alua_drop_tg_pt_gp(struct config_group * group,struct config_item * item)3242 static void target_core_alua_drop_tg_pt_gp(
3243 struct config_group *group,
3244 struct config_item *item)
3245 {
3246 struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
3247 struct t10_alua_tg_pt_gp, tg_pt_gp_group);
3248
3249 pr_debug("Target_Core_ConfigFS: Releasing ALUA Target Port"
3250 " Group: alua/tg_pt_gps/%s, ID: %hu\n",
3251 config_item_name(item), tg_pt_gp->tg_pt_gp_id);
3252 /*
3253 * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release()
3254 * -> target_core_alua_tg_pt_gp_release().
3255 */
3256 config_item_put(item);
3257 }
3258
3259 static struct configfs_group_operations target_core_alua_tg_pt_gps_group_ops = {
3260 .make_group = &target_core_alua_create_tg_pt_gp,
3261 .drop_item = &target_core_alua_drop_tg_pt_gp,
3262 };
3263
3264 TB_CIT_SETUP(dev_alua_tg_pt_gps, NULL, &target_core_alua_tg_pt_gps_group_ops, NULL);
3265
3266 /* End functions for struct config_item_type tb_alua_tg_pt_gps_cit */
3267
3268 /* Start functions for struct config_item_type target_core_alua_cit */
3269
3270 /*
3271 * target_core_alua_cit is a ConfigFS group that lives under
3272 * /sys/kernel/config/target/core/alua. There are default groups
3273 * core/alua/lu_gps and core/alua/tg_pt_gps that are attached to
3274 * target_core_alua_cit in target_core_init_configfs() below.
3275 */
3276 static const struct config_item_type target_core_alua_cit = {
3277 .ct_item_ops = NULL,
3278 .ct_attrs = NULL,
3279 .ct_owner = THIS_MODULE,
3280 };
3281
3282 /* End functions for struct config_item_type target_core_alua_cit */
3283
3284 /* Start functions for struct config_item_type tb_dev_stat_cit */
3285
target_core_stat_mkdir(struct config_group * group,const char * name)3286 static struct config_group *target_core_stat_mkdir(
3287 struct config_group *group,
3288 const char *name)
3289 {
3290 return ERR_PTR(-ENOSYS);
3291 }
3292
target_core_stat_rmdir(struct config_group * group,struct config_item * item)3293 static void target_core_stat_rmdir(
3294 struct config_group *group,
3295 struct config_item *item)
3296 {
3297 return;
3298 }
3299
3300 static struct configfs_group_operations target_core_stat_group_ops = {
3301 .make_group = &target_core_stat_mkdir,
3302 .drop_item = &target_core_stat_rmdir,
3303 };
3304
3305 TB_CIT_SETUP(dev_stat, NULL, &target_core_stat_group_ops, NULL);
3306
3307 /* End functions for struct config_item_type tb_dev_stat_cit */
3308
3309 /* Start functions for struct config_item_type target_core_hba_cit */
3310
target_core_make_subdev(struct config_group * group,const char * name)3311 static struct config_group *target_core_make_subdev(
3312 struct config_group *group,
3313 const char *name)
3314 {
3315 struct t10_alua_tg_pt_gp *tg_pt_gp;
3316 struct config_item *hba_ci = &group->cg_item;
3317 struct se_hba *hba = item_to_hba(hba_ci);
3318 struct target_backend *tb = hba->backend;
3319 struct se_device *dev;
3320 int errno = -ENOMEM, ret;
3321
3322 ret = mutex_lock_interruptible(&hba->hba_access_mutex);
3323 if (ret)
3324 return ERR_PTR(ret);
3325
3326 dev = target_alloc_device(hba, name);
3327 if (!dev)
3328 goto out_unlock;
3329
3330 config_group_init_type_name(&dev->dev_group, name, &tb->tb_dev_cit);
3331
3332 config_group_init_type_name(&dev->dev_action_group, "action",
3333 &tb->tb_dev_action_cit);
3334 configfs_add_default_group(&dev->dev_action_group, &dev->dev_group);
3335
3336 config_group_init_type_name(&dev->dev_attrib.da_group, "attrib",
3337 &tb->tb_dev_attrib_cit);
3338 configfs_add_default_group(&dev->dev_attrib.da_group, &dev->dev_group);
3339
3340 config_group_init_type_name(&dev->dev_pr_group, "pr",
3341 &tb->tb_dev_pr_cit);
3342 configfs_add_default_group(&dev->dev_pr_group, &dev->dev_group);
3343
3344 config_group_init_type_name(&dev->t10_wwn.t10_wwn_group, "wwn",
3345 &tb->tb_dev_wwn_cit);
3346 configfs_add_default_group(&dev->t10_wwn.t10_wwn_group,
3347 &dev->dev_group);
3348
3349 config_group_init_type_name(&dev->t10_alua.alua_tg_pt_gps_group,
3350 "alua", &tb->tb_dev_alua_tg_pt_gps_cit);
3351 configfs_add_default_group(&dev->t10_alua.alua_tg_pt_gps_group,
3352 &dev->dev_group);
3353
3354 config_group_init_type_name(&dev->dev_stat_grps.stat_group,
3355 "statistics", &tb->tb_dev_stat_cit);
3356 configfs_add_default_group(&dev->dev_stat_grps.stat_group,
3357 &dev->dev_group);
3358
3359 /*
3360 * Add core/$HBA/$DEV/alua/default_tg_pt_gp
3361 */
3362 tg_pt_gp = core_alua_allocate_tg_pt_gp(dev, "default_tg_pt_gp", 1);
3363 if (!tg_pt_gp)
3364 goto out_free_device;
3365 dev->t10_alua.default_tg_pt_gp = tg_pt_gp;
3366
3367 config_group_init_type_name(&tg_pt_gp->tg_pt_gp_group,
3368 "default_tg_pt_gp", &target_core_alua_tg_pt_gp_cit);
3369 configfs_add_default_group(&tg_pt_gp->tg_pt_gp_group,
3370 &dev->t10_alua.alua_tg_pt_gps_group);
3371
3372 /*
3373 * Add core/$HBA/$DEV/statistics/ default groups
3374 */
3375 target_stat_setup_dev_default_groups(dev);
3376
3377 mutex_lock(&target_devices_lock);
3378 target_devices++;
3379 mutex_unlock(&target_devices_lock);
3380
3381 mutex_unlock(&hba->hba_access_mutex);
3382 return &dev->dev_group;
3383
3384 out_free_device:
3385 target_free_device(dev);
3386 out_unlock:
3387 mutex_unlock(&hba->hba_access_mutex);
3388 return ERR_PTR(errno);
3389 }
3390
target_core_drop_subdev(struct config_group * group,struct config_item * item)3391 static void target_core_drop_subdev(
3392 struct config_group *group,
3393 struct config_item *item)
3394 {
3395 struct config_group *dev_cg = to_config_group(item);
3396 struct se_device *dev =
3397 container_of(dev_cg, struct se_device, dev_group);
3398 struct se_hba *hba;
3399
3400 hba = item_to_hba(&dev->se_hba->hba_group.cg_item);
3401
3402 mutex_lock(&hba->hba_access_mutex);
3403
3404 configfs_remove_default_groups(&dev->dev_stat_grps.stat_group);
3405 configfs_remove_default_groups(&dev->t10_alua.alua_tg_pt_gps_group);
3406
3407 /*
3408 * core_alua_free_tg_pt_gp() is called from ->default_tg_pt_gp
3409 * directly from target_core_alua_tg_pt_gp_release().
3410 */
3411 dev->t10_alua.default_tg_pt_gp = NULL;
3412
3413 configfs_remove_default_groups(dev_cg);
3414
3415 /*
3416 * se_dev is released from target_core_dev_item_ops->release()
3417 */
3418 config_item_put(item);
3419
3420 mutex_lock(&target_devices_lock);
3421 target_devices--;
3422 mutex_unlock(&target_devices_lock);
3423
3424 mutex_unlock(&hba->hba_access_mutex);
3425 }
3426
3427 static struct configfs_group_operations target_core_hba_group_ops = {
3428 .make_group = target_core_make_subdev,
3429 .drop_item = target_core_drop_subdev,
3430 };
3431
3432
to_hba(struct config_item * item)3433 static inline struct se_hba *to_hba(struct config_item *item)
3434 {
3435 return container_of(to_config_group(item), struct se_hba, hba_group);
3436 }
3437
target_hba_info_show(struct config_item * item,char * page)3438 static ssize_t target_hba_info_show(struct config_item *item, char *page)
3439 {
3440 struct se_hba *hba = to_hba(item);
3441
3442 return sprintf(page, "HBA Index: %d plugin: %s version: %s\n",
3443 hba->hba_id, hba->backend->ops->name,
3444 TARGET_CORE_VERSION);
3445 }
3446
target_hba_mode_show(struct config_item * item,char * page)3447 static ssize_t target_hba_mode_show(struct config_item *item, char *page)
3448 {
3449 struct se_hba *hba = to_hba(item);
3450 int hba_mode = 0;
3451
3452 if (hba->hba_flags & HBA_FLAGS_PSCSI_MODE)
3453 hba_mode = 1;
3454
3455 return sprintf(page, "%d\n", hba_mode);
3456 }
3457
target_hba_mode_store(struct config_item * item,const char * page,size_t count)3458 static ssize_t target_hba_mode_store(struct config_item *item,
3459 const char *page, size_t count)
3460 {
3461 struct se_hba *hba = to_hba(item);
3462 unsigned long mode_flag;
3463 int ret;
3464
3465 if (hba->backend->ops->pmode_enable_hba == NULL)
3466 return -EINVAL;
3467
3468 ret = kstrtoul(page, 0, &mode_flag);
3469 if (ret < 0) {
3470 pr_err("Unable to extract hba mode flag: %d\n", ret);
3471 return ret;
3472 }
3473
3474 if (hba->dev_count) {
3475 pr_err("Unable to set hba_mode with active devices\n");
3476 return -EINVAL;
3477 }
3478
3479 ret = hba->backend->ops->pmode_enable_hba(hba, mode_flag);
3480 if (ret < 0)
3481 return -EINVAL;
3482 if (ret > 0)
3483 hba->hba_flags |= HBA_FLAGS_PSCSI_MODE;
3484 else if (ret == 0)
3485 hba->hba_flags &= ~HBA_FLAGS_PSCSI_MODE;
3486
3487 return count;
3488 }
3489
3490 CONFIGFS_ATTR_RO(target_, hba_info);
3491 CONFIGFS_ATTR(target_, hba_mode);
3492
target_core_hba_release(struct config_item * item)3493 static void target_core_hba_release(struct config_item *item)
3494 {
3495 struct se_hba *hba = container_of(to_config_group(item),
3496 struct se_hba, hba_group);
3497 core_delete_hba(hba);
3498 }
3499
3500 static struct configfs_attribute *target_core_hba_attrs[] = {
3501 &target_attr_hba_info,
3502 &target_attr_hba_mode,
3503 NULL,
3504 };
3505
3506 static struct configfs_item_operations target_core_hba_item_ops = {
3507 .release = target_core_hba_release,
3508 };
3509
3510 static const struct config_item_type target_core_hba_cit = {
3511 .ct_item_ops = &target_core_hba_item_ops,
3512 .ct_group_ops = &target_core_hba_group_ops,
3513 .ct_attrs = target_core_hba_attrs,
3514 .ct_owner = THIS_MODULE,
3515 };
3516
target_core_call_addhbatotarget(struct config_group * group,const char * name)3517 static struct config_group *target_core_call_addhbatotarget(
3518 struct config_group *group,
3519 const char *name)
3520 {
3521 char *se_plugin_str, *str, *str2;
3522 struct se_hba *hba;
3523 char buf[TARGET_CORE_NAME_MAX_LEN] = { };
3524 unsigned long plugin_dep_id = 0;
3525 int ret;
3526
3527 if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) {
3528 pr_err("Passed *name strlen(): %d exceeds"
3529 " TARGET_CORE_NAME_MAX_LEN: %d\n", (int)strlen(name),
3530 TARGET_CORE_NAME_MAX_LEN);
3531 return ERR_PTR(-ENAMETOOLONG);
3532 }
3533 snprintf(buf, TARGET_CORE_NAME_MAX_LEN, "%s", name);
3534
3535 str = strstr(buf, "_");
3536 if (!str) {
3537 pr_err("Unable to locate \"_\" for $SUBSYSTEM_PLUGIN_$HOST_ID\n");
3538 return ERR_PTR(-EINVAL);
3539 }
3540 se_plugin_str = buf;
3541 /*
3542 * Special case for subsystem plugins that have "_" in their names.
3543 * Namely rd_direct and rd_mcp..
3544 */
3545 str2 = strstr(str+1, "_");
3546 if (str2) {
3547 *str2 = '\0'; /* Terminate for *se_plugin_str */
3548 str2++; /* Skip to start of plugin dependent ID */
3549 str = str2;
3550 } else {
3551 *str = '\0'; /* Terminate for *se_plugin_str */
3552 str++; /* Skip to start of plugin dependent ID */
3553 }
3554
3555 ret = kstrtoul(str, 0, &plugin_dep_id);
3556 if (ret < 0) {
3557 pr_err("kstrtoul() returned %d for"
3558 " plugin_dep_id\n", ret);
3559 return ERR_PTR(ret);
3560 }
3561 /*
3562 * Load up TCM subsystem plugins if they have not already been loaded.
3563 */
3564 transport_subsystem_check_init();
3565
3566 hba = core_alloc_hba(se_plugin_str, plugin_dep_id, 0);
3567 if (IS_ERR(hba))
3568 return ERR_CAST(hba);
3569
3570 config_group_init_type_name(&hba->hba_group, name,
3571 &target_core_hba_cit);
3572
3573 return &hba->hba_group;
3574 }
3575
target_core_call_delhbafromtarget(struct config_group * group,struct config_item * item)3576 static void target_core_call_delhbafromtarget(
3577 struct config_group *group,
3578 struct config_item *item)
3579 {
3580 /*
3581 * core_delete_hba() is called from target_core_hba_item_ops->release()
3582 * -> target_core_hba_release()
3583 */
3584 config_item_put(item);
3585 }
3586
3587 static struct configfs_group_operations target_core_group_ops = {
3588 .make_group = target_core_call_addhbatotarget,
3589 .drop_item = target_core_call_delhbafromtarget,
3590 };
3591
3592 static const struct config_item_type target_core_cit = {
3593 .ct_item_ops = NULL,
3594 .ct_group_ops = &target_core_group_ops,
3595 .ct_attrs = NULL,
3596 .ct_owner = THIS_MODULE,
3597 };
3598
3599 /* Stop functions for struct config_item_type target_core_hba_cit */
3600
target_setup_backend_cits(struct target_backend * tb)3601 void target_setup_backend_cits(struct target_backend *tb)
3602 {
3603 target_core_setup_dev_cit(tb);
3604 target_core_setup_dev_action_cit(tb);
3605 target_core_setup_dev_attrib_cit(tb);
3606 target_core_setup_dev_pr_cit(tb);
3607 target_core_setup_dev_wwn_cit(tb);
3608 target_core_setup_dev_alua_tg_pt_gps_cit(tb);
3609 target_core_setup_dev_stat_cit(tb);
3610 }
3611
target_init_dbroot(void)3612 static void target_init_dbroot(void)
3613 {
3614 struct file *fp;
3615
3616 snprintf(db_root_stage, DB_ROOT_LEN, DB_ROOT_PREFERRED);
3617 fp = filp_open(db_root_stage, O_RDONLY, 0);
3618 if (IS_ERR(fp)) {
3619 pr_err("db_root: cannot open: %s\n", db_root_stage);
3620 return;
3621 }
3622 if (!S_ISDIR(file_inode(fp)->i_mode)) {
3623 filp_close(fp, NULL);
3624 pr_err("db_root: not a valid directory: %s\n", db_root_stage);
3625 return;
3626 }
3627 filp_close(fp, NULL);
3628
3629 strncpy(db_root, db_root_stage, DB_ROOT_LEN);
3630 pr_debug("Target_Core_ConfigFS: db_root set to %s\n", db_root);
3631 }
3632
target_core_init_configfs(void)3633 static int __init target_core_init_configfs(void)
3634 {
3635 struct configfs_subsystem *subsys = &target_core_fabrics;
3636 struct t10_alua_lu_gp *lu_gp;
3637 struct cred *kern_cred;
3638 const struct cred *old_cred;
3639 int ret;
3640
3641 pr_debug("TARGET_CORE[0]: Loading Generic Kernel Storage"
3642 " Engine: %s on %s/%s on "UTS_RELEASE"\n",
3643 TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
3644
3645 config_group_init(&subsys->su_group);
3646 mutex_init(&subsys->su_mutex);
3647
3648 ret = init_se_kmem_caches();
3649 if (ret < 0)
3650 return ret;
3651 /*
3652 * Create $CONFIGFS/target/core default group for HBA <-> Storage Object
3653 * and ALUA Logical Unit Group and Target Port Group infrastructure.
3654 */
3655 config_group_init_type_name(&target_core_hbagroup, "core",
3656 &target_core_cit);
3657 configfs_add_default_group(&target_core_hbagroup, &subsys->su_group);
3658
3659 /*
3660 * Create ALUA infrastructure under /sys/kernel/config/target/core/alua/
3661 */
3662 config_group_init_type_name(&alua_group, "alua", &target_core_alua_cit);
3663 configfs_add_default_group(&alua_group, &target_core_hbagroup);
3664
3665 /*
3666 * Add ALUA Logical Unit Group and Target Port Group ConfigFS
3667 * groups under /sys/kernel/config/target/core/alua/
3668 */
3669 config_group_init_type_name(&alua_lu_gps_group, "lu_gps",
3670 &target_core_alua_lu_gps_cit);
3671 configfs_add_default_group(&alua_lu_gps_group, &alua_group);
3672
3673 /*
3674 * Add core/alua/lu_gps/default_lu_gp
3675 */
3676 lu_gp = core_alua_allocate_lu_gp("default_lu_gp", 1);
3677 if (IS_ERR(lu_gp)) {
3678 ret = -ENOMEM;
3679 goto out_global;
3680 }
3681
3682 config_group_init_type_name(&lu_gp->lu_gp_group, "default_lu_gp",
3683 &target_core_alua_lu_gp_cit);
3684 configfs_add_default_group(&lu_gp->lu_gp_group, &alua_lu_gps_group);
3685
3686 default_lu_gp = lu_gp;
3687
3688 /*
3689 * Register the target_core_mod subsystem with configfs.
3690 */
3691 ret = configfs_register_subsystem(subsys);
3692 if (ret < 0) {
3693 pr_err("Error %d while registering subsystem %s\n",
3694 ret, subsys->su_group.cg_item.ci_namebuf);
3695 goto out_global;
3696 }
3697 pr_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
3698 " Infrastructure: "TARGET_CORE_VERSION" on %s/%s"
3699 " on "UTS_RELEASE"\n", utsname()->sysname, utsname()->machine);
3700 /*
3701 * Register built-in RAMDISK subsystem logic for virtual LUN 0
3702 */
3703 ret = rd_module_init();
3704 if (ret < 0)
3705 goto out;
3706
3707 ret = core_dev_setup_virtual_lun0();
3708 if (ret < 0)
3709 goto out;
3710
3711 ret = target_xcopy_setup_pt();
3712 if (ret < 0)
3713 goto out;
3714
3715 /* We use the kernel credentials to access the target directory */
3716 kern_cred = prepare_kernel_cred(&init_task);
3717 if (!kern_cred) {
3718 ret = -ENOMEM;
3719 goto out;
3720 }
3721 old_cred = override_creds(kern_cred);
3722 target_init_dbroot();
3723 revert_creds(old_cred);
3724 put_cred(kern_cred);
3725
3726 return 0;
3727
3728 out:
3729 target_xcopy_release_pt();
3730 configfs_unregister_subsystem(subsys);
3731 core_dev_release_virtual_lun0();
3732 rd_module_exit();
3733 out_global:
3734 if (default_lu_gp) {
3735 core_alua_free_lu_gp(default_lu_gp);
3736 default_lu_gp = NULL;
3737 }
3738 release_se_kmem_caches();
3739 return ret;
3740 }
3741
target_core_exit_configfs(void)3742 static void __exit target_core_exit_configfs(void)
3743 {
3744 configfs_remove_default_groups(&alua_lu_gps_group);
3745 configfs_remove_default_groups(&alua_group);
3746 configfs_remove_default_groups(&target_core_hbagroup);
3747
3748 /*
3749 * We expect subsys->su_group.default_groups to be released
3750 * by configfs subsystem provider logic..
3751 */
3752 configfs_unregister_subsystem(&target_core_fabrics);
3753
3754 core_alua_free_lu_gp(default_lu_gp);
3755 default_lu_gp = NULL;
3756
3757 pr_debug("TARGET_CORE[0]: Released ConfigFS Fabric"
3758 " Infrastructure\n");
3759
3760 core_dev_release_virtual_lun0();
3761 rd_module_exit();
3762 target_xcopy_release_pt();
3763 release_se_kmem_caches();
3764 }
3765
3766 MODULE_DESCRIPTION("Target_Core_Mod/ConfigFS");
3767 MODULE_AUTHOR("nab@Linux-iSCSI.org");
3768 MODULE_LICENSE("GPL");
3769
3770 module_init(target_core_init_configfs);
3771 module_exit(target_core_exit_configfs);
3772