1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*******************************************************************************
3  * Filename:  target_core_hba.c
4  *
5  * This file contains the TCM HBA Transport related functions.
6  *
7  * (c) Copyright 2003-2013 Datera, Inc.
8  *
9  * Nicholas A. Bellinger <nab@kernel.org>
10  *
11  ******************************************************************************/
12 
13 #include <linux/net.h>
14 #include <linux/string.h>
15 #include <linux/timer.h>
16 #include <linux/slab.h>
17 #include <linux/spinlock.h>
18 #include <linux/in.h>
19 #include <linux/module.h>
20 #include <net/sock.h>
21 #include <net/tcp.h>
22 
23 #include <target/target_core_base.h>
24 #include <target/target_core_backend.h>
25 #include <target/target_core_fabric.h>
26 
27 #include "target_core_internal.h"
28 
29 static LIST_HEAD(backend_list);
30 static DEFINE_MUTEX(backend_mutex);
31 
32 static u32 hba_id_counter;
33 
34 static DEFINE_SPINLOCK(hba_lock);
35 static LIST_HEAD(hba_list);
36 
37 
38 int transport_backend_register(const struct target_backend_ops *ops)
39 {
40 	struct target_backend *tb, *old;
41 
42 	tb = kzalloc(sizeof(*tb), GFP_KERNEL);
43 	if (!tb)
44 		return -ENOMEM;
45 	tb->ops = ops;
46 
47 	mutex_lock(&backend_mutex);
48 	list_for_each_entry(old, &backend_list, list) {
49 		if (!strcmp(old->ops->name, ops->name)) {
50 			pr_err("backend %s already registered.\n", ops->name);
51 			mutex_unlock(&backend_mutex);
52 			kfree(tb);
53 			return -EEXIST;
54 		}
55 	}
56 	target_setup_backend_cits(tb);
57 	list_add_tail(&tb->list, &backend_list);
58 	mutex_unlock(&backend_mutex);
59 
60 	pr_debug("TCM: Registered subsystem plugin: %s struct module: %p\n",
61 			ops->name, ops->owner);
62 	return 0;
63 }
64 EXPORT_SYMBOL(transport_backend_register);
65 
66 void target_backend_unregister(const struct target_backend_ops *ops)
67 {
68 	struct target_backend *tb;
69 
70 	mutex_lock(&backend_mutex);
71 	list_for_each_entry(tb, &backend_list, list) {
72 		if (tb->ops == ops) {
73 			list_del(&tb->list);
74 			mutex_unlock(&backend_mutex);
75 			/*
76 			 * Wait for any outstanding backend driver ->rcu_head
77 			 * callbacks to complete post TBO->free_device() ->
78 			 * call_rcu(), before allowing backend driver module
79 			 * unload of target_backend_ops->owner to proceed.
80 			 */
81 			rcu_barrier();
82 			kfree(tb);
83 			return;
84 		}
85 	}
86 	mutex_unlock(&backend_mutex);
87 }
88 EXPORT_SYMBOL(target_backend_unregister);
89 
90 static struct target_backend *core_get_backend(const char *name)
91 {
92 	struct target_backend *tb;
93 
94 	mutex_lock(&backend_mutex);
95 	list_for_each_entry(tb, &backend_list, list) {
96 		if (!strcmp(tb->ops->name, name))
97 			goto found;
98 	}
99 	mutex_unlock(&backend_mutex);
100 	return NULL;
101 found:
102 	if (tb->ops->owner && !try_module_get(tb->ops->owner))
103 		tb = NULL;
104 	mutex_unlock(&backend_mutex);
105 	return tb;
106 }
107 
108 struct se_hba *
109 core_alloc_hba(const char *plugin_name, u32 plugin_dep_id, u32 hba_flags)
110 {
111 	struct se_hba *hba;
112 	int ret = 0;
113 
114 	hba = kzalloc(sizeof(*hba), GFP_KERNEL);
115 	if (!hba) {
116 		pr_err("Unable to allocate struct se_hba\n");
117 		return ERR_PTR(-ENOMEM);
118 	}
119 
120 	spin_lock_init(&hba->device_lock);
121 	mutex_init(&hba->hba_access_mutex);
122 
123 	hba->hba_index = scsi_get_new_index(SCSI_INST_INDEX);
124 	hba->hba_flags |= hba_flags;
125 
126 	hba->backend = core_get_backend(plugin_name);
127 	if (!hba->backend) {
128 		ret = -EINVAL;
129 		goto out_free_hba;
130 	}
131 
132 	ret = hba->backend->ops->attach_hba(hba, plugin_dep_id);
133 	if (ret < 0)
134 		goto out_module_put;
135 
136 	spin_lock(&hba_lock);
137 	hba->hba_id = hba_id_counter++;
138 	list_add_tail(&hba->hba_node, &hba_list);
139 	spin_unlock(&hba_lock);
140 
141 	pr_debug("CORE_HBA[%d] - Attached HBA to Generic Target"
142 			" Core\n", hba->hba_id);
143 
144 	return hba;
145 
146 out_module_put:
147 	module_put(hba->backend->ops->owner);
148 	hba->backend = NULL;
149 out_free_hba:
150 	kfree(hba);
151 	return ERR_PTR(ret);
152 }
153 
154 int
155 core_delete_hba(struct se_hba *hba)
156 {
157 	WARN_ON(hba->dev_count);
158 
159 	hba->backend->ops->detach_hba(hba);
160 
161 	spin_lock(&hba_lock);
162 	list_del(&hba->hba_node);
163 	spin_unlock(&hba_lock);
164 
165 	pr_debug("CORE_HBA[%d] - Detached HBA from Generic Target"
166 			" Core\n", hba->hba_id);
167 
168 	module_put(hba->backend->ops->owner);
169 
170 	hba->backend = NULL;
171 	kfree(hba);
172 	return 0;
173 }
174 
175 bool target_sense_desc_format(struct se_device *dev)
176 {
177 	return (dev) ? dev->transport->get_blocks(dev) > U32_MAX : false;
178 }
179