Commit | Line | Data |
---|---|---|
a07b4970 CH |
1 | /* |
2 | * Discovery service for the NVMe over Fabrics target. | |
3 | * Copyright (C) 2016 Intel Corporation. All rights reserved. | |
4 | * | |
5 | * This program is free software; you can redistribute it and/or | |
6 | * modify it under the terms of the GNU General Public License version | |
7 | * 2 as published by the Free Software Foundation. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | */ | |
14 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt | |
15 | #include <linux/slab.h> | |
16 | #include <generated/utsrelease.h> | |
17 | #include "nvmet.h" | |
18 | ||
19 | struct nvmet_subsys *nvmet_disc_subsys; | |
20 | ||
03198c4d | 21 | static u64 nvmet_genctr; |
a07b4970 | 22 | |
b662a078 JS |
23 | static void __nvmet_disc_changed(struct nvmet_port *port, |
24 | struct nvmet_ctrl *ctrl) | |
25 | { | |
26 | if (ctrl->port != port) | |
27 | return; | |
28 | ||
29 | if (nvmet_aen_bit_disabled(ctrl, NVME_AEN_BIT_DISC_CHANGE)) | |
30 | return; | |
31 | ||
32 | nvmet_add_async_event(ctrl, NVME_AER_TYPE_NOTICE, | |
33 | NVME_AER_NOTICE_DISC_CHANGED, NVME_LOG_DISC); | |
34 | } | |
35 | ||
36 | void nvmet_port_disc_changed(struct nvmet_port *port, | |
37 | struct nvmet_subsys *subsys) | |
38 | { | |
39 | struct nvmet_ctrl *ctrl; | |
40 | ||
41 | nvmet_genctr++; | |
42 | ||
43 | list_for_each_entry(ctrl, &nvmet_disc_subsys->ctrls, subsys_entry) { | |
44 | if (subsys && !nvmet_host_allowed(subsys, ctrl->hostnqn)) | |
45 | continue; | |
46 | ||
47 | __nvmet_disc_changed(port, ctrl); | |
48 | } | |
49 | } | |
50 | ||
51 | static void __nvmet_subsys_disc_changed(struct nvmet_port *port, | |
52 | struct nvmet_subsys *subsys, | |
53 | struct nvmet_host *host) | |
54 | { | |
55 | struct nvmet_ctrl *ctrl; | |
56 | ||
57 | list_for_each_entry(ctrl, &nvmet_disc_subsys->ctrls, subsys_entry) { | |
58 | if (host && strcmp(nvmet_host_name(host), ctrl->hostnqn)) | |
59 | continue; | |
60 | ||
61 | __nvmet_disc_changed(port, ctrl); | |
62 | } | |
63 | } | |
64 | ||
65 | void nvmet_subsys_disc_changed(struct nvmet_subsys *subsys, | |
66 | struct nvmet_host *host) | |
67 | { | |
68 | struct nvmet_port *port; | |
69 | struct nvmet_subsys_link *s; | |
70 | ||
71 | nvmet_genctr++; | |
72 | ||
73 | list_for_each_entry(port, nvmet_ports, global_entry) | |
74 | list_for_each_entry(s, &port->subsystems, entry) { | |
75 | if (s->subsys != subsys) | |
76 | continue; | |
77 | __nvmet_subsys_disc_changed(port, subsys, host); | |
78 | } | |
79 | } | |
80 | ||
a07b4970 CH |
81 | void nvmet_referral_enable(struct nvmet_port *parent, struct nvmet_port *port) |
82 | { | |
83 | down_write(&nvmet_config_sem); | |
84 | if (list_empty(&port->entry)) { | |
85 | list_add_tail(&port->entry, &parent->referrals); | |
86 | port->enabled = true; | |
b662a078 | 87 | nvmet_port_disc_changed(parent, NULL); |
a07b4970 CH |
88 | } |
89 | up_write(&nvmet_config_sem); | |
90 | } | |
91 | ||
b662a078 | 92 | void nvmet_referral_disable(struct nvmet_port *parent, struct nvmet_port *port) |
a07b4970 CH |
93 | { |
94 | down_write(&nvmet_config_sem); | |
95 | if (!list_empty(&port->entry)) { | |
96 | port->enabled = false; | |
97 | list_del_init(&port->entry); | |
b662a078 | 98 | nvmet_port_disc_changed(parent, NULL); |
a07b4970 CH |
99 | } |
100 | up_write(&nvmet_config_sem); | |
101 | } | |
102 | ||
103 | static void nvmet_format_discovery_entry(struct nvmf_disc_rsp_page_hdr *hdr, | |
4c652685 SG |
104 | struct nvmet_port *port, char *subsys_nqn, char *traddr, |
105 | u8 type, u32 numrec) | |
a07b4970 CH |
106 | { |
107 | struct nvmf_disc_rsp_page_entry *e = &hdr->entries[numrec]; | |
108 | ||
109 | e->trtype = port->disc_addr.trtype; | |
110 | e->adrfam = port->disc_addr.adrfam; | |
111 | e->treq = port->disc_addr.treq; | |
112 | e->portid = port->disc_addr.portid; | |
113 | /* we support only dynamic controllers */ | |
114 | e->cntlid = cpu_to_le16(NVME_CNTLID_DYNAMIC); | |
7aa1f427 | 115 | e->asqsz = cpu_to_le16(NVME_AQ_DEPTH); |
a446c084 | 116 | e->subtype = type; |
a07b4970 | 117 | memcpy(e->trsvcid, port->disc_addr.trsvcid, NVMF_TRSVCID_SIZE); |
4c652685 | 118 | memcpy(e->traddr, traddr, NVMF_TRADDR_SIZE); |
a07b4970 | 119 | memcpy(e->tsas.common, port->disc_addr.tsas.common, NVMF_TSAS_SIZE); |
6038aa53 | 120 | strncpy(e->subnqn, subsys_nqn, NVMF_NQN_SIZE); |
a07b4970 CH |
121 | } |
122 | ||
4c652685 SG |
123 | /* |
124 | * nvmet_set_disc_traddr - set a correct discovery log entry traddr | |
125 | * | |
126 | * IP based transports (e.g RDMA) can listen on "any" ipv4/ipv6 addresses | |
127 | * (INADDR_ANY or IN6ADDR_ANY_INIT). The discovery log page traddr reply | |
128 | * must not contain that "any" IP address. If the transport implements | |
129 | * .disc_traddr, use it. this callback will set the discovery traddr | |
130 | * from the req->port address in case the port in question listens | |
131 | * "any" IP address. | |
132 | */ | |
133 | static void nvmet_set_disc_traddr(struct nvmet_req *req, struct nvmet_port *port, | |
134 | char *traddr) | |
135 | { | |
136 | if (req->ops->disc_traddr) | |
137 | req->ops->disc_traddr(req, port, traddr); | |
138 | else | |
139 | memcpy(traddr, port->disc_addr.traddr, NVMF_TRADDR_SIZE); | |
140 | } | |
141 | ||
a07b4970 CH |
142 | static void nvmet_execute_get_disc_log_page(struct nvmet_req *req) |
143 | { | |
144 | const int entry_size = sizeof(struct nvmf_disc_rsp_page_entry); | |
145 | struct nvmet_ctrl *ctrl = req->sq->ctrl; | |
146 | struct nvmf_disc_rsp_page_hdr *hdr; | |
147 | size_t data_len = nvmet_get_log_page_len(req->cmd); | |
148 | size_t alloc_len = max(data_len, sizeof(*hdr)); | |
149 | int residual_len = data_len - sizeof(*hdr); | |
150 | struct nvmet_subsys_link *p; | |
151 | struct nvmet_port *r; | |
152 | u32 numrec = 0; | |
153 | u16 status = 0; | |
154 | ||
155 | /* | |
156 | * Make sure we're passing at least a buffer of response header size. | |
157 | * If host provided data len is less than the header size, only the | |
158 | * number of bytes requested by host will be sent to host. | |
159 | */ | |
160 | hdr = kzalloc(alloc_len, GFP_KERNEL); | |
161 | if (!hdr) { | |
162 | status = NVME_SC_INTERNAL; | |
163 | goto out; | |
164 | } | |
165 | ||
166 | down_read(&nvmet_config_sem); | |
167 | list_for_each_entry(p, &req->port->subsystems, entry) { | |
253928ee | 168 | if (!nvmet_host_allowed(p->subsys, ctrl->hostnqn)) |
a07b4970 CH |
169 | continue; |
170 | if (residual_len >= entry_size) { | |
4c652685 SG |
171 | char traddr[NVMF_TRADDR_SIZE]; |
172 | ||
173 | nvmet_set_disc_traddr(req, req->port, traddr); | |
a07b4970 | 174 | nvmet_format_discovery_entry(hdr, req->port, |
4c652685 | 175 | p->subsys->subsysnqn, traddr, |
a07b4970 CH |
176 | NVME_NQN_NVME, numrec); |
177 | residual_len -= entry_size; | |
178 | } | |
179 | numrec++; | |
180 | } | |
181 | ||
182 | list_for_each_entry(r, &req->port->referrals, entry) { | |
183 | if (residual_len >= entry_size) { | |
184 | nvmet_format_discovery_entry(hdr, r, | |
185 | NVME_DISC_SUBSYS_NAME, | |
4c652685 | 186 | r->disc_addr.traddr, |
a07b4970 CH |
187 | NVME_NQN_DISC, numrec); |
188 | residual_len -= entry_size; | |
189 | } | |
190 | numrec++; | |
191 | } | |
192 | ||
193 | hdr->genctr = cpu_to_le64(nvmet_genctr); | |
194 | hdr->numrec = cpu_to_le64(numrec); | |
195 | hdr->recfmt = cpu_to_le16(0); | |
196 | ||
b662a078 JS |
197 | nvmet_clear_aen_bit(req, NVME_AEN_BIT_DISC_CHANGE); |
198 | ||
a07b4970 CH |
199 | up_read(&nvmet_config_sem); |
200 | ||
201 | status = nvmet_copy_to_sgl(req, 0, hdr, data_len); | |
202 | kfree(hdr); | |
203 | out: | |
204 | nvmet_req_complete(req, status); | |
205 | } | |
206 | ||
207 | static void nvmet_execute_identify_disc_ctrl(struct nvmet_req *req) | |
208 | { | |
209 | struct nvmet_ctrl *ctrl = req->sq->ctrl; | |
210 | struct nvme_id_ctrl *id; | |
211 | u16 status = 0; | |
212 | ||
213 | id = kzalloc(sizeof(*id), GFP_KERNEL); | |
214 | if (!id) { | |
215 | status = NVME_SC_INTERNAL; | |
216 | goto out; | |
217 | } | |
218 | ||
219 | memset(id->fr, ' ', sizeof(id->fr)); | |
220 | strncpy((char *)id->fr, UTS_RELEASE, sizeof(id->fr)); | |
221 | ||
222 | /* no limit on data transfer sizes for now */ | |
223 | id->mdts = 0; | |
224 | id->cntlid = cpu_to_le16(ctrl->cntlid); | |
225 | id->ver = cpu_to_le32(ctrl->subsys->ver); | |
226 | id->lpa = (1 << 2); | |
227 | ||
228 | /* no enforcement soft-limit for maxcmd - pick arbitrary high value */ | |
229 | id->maxcmd = cpu_to_le16(NVMET_MAX_CMD); | |
230 | ||
231 | id->sgls = cpu_to_le32(1 << 0); /* we always support SGLs */ | |
232 | if (ctrl->ops->has_keyed_sgls) | |
233 | id->sgls |= cpu_to_le32(1 << 2); | |
0d5ee2b2 | 234 | if (req->port->inline_data_size) |
a07b4970 CH |
235 | id->sgls |= cpu_to_le32(1 << 20); |
236 | ||
b662a078 JS |
237 | id->oaes = cpu_to_le32(NVMET_DISC_AEN_CFG_OPTIONAL); |
238 | ||
5eadc9cc | 239 | strlcpy(id->subnqn, ctrl->subsys->subsysnqn, sizeof(id->subnqn)); |
a07b4970 CH |
240 | |
241 | status = nvmet_copy_to_sgl(req, 0, id, sizeof(*id)); | |
242 | ||
243 | kfree(id); | |
244 | out: | |
245 | nvmet_req_complete(req, status); | |
246 | } | |
247 | ||
6a8ec0ac JS |
248 | static void nvmet_execute_disc_set_features(struct nvmet_req *req) |
249 | { | |
b7c8f366 | 250 | u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10); |
6a8ec0ac JS |
251 | u16 stat; |
252 | ||
253 | switch (cdw10 & 0xff) { | |
254 | case NVME_FEAT_KATO: | |
255 | stat = nvmet_set_feat_kato(req); | |
256 | break; | |
257 | case NVME_FEAT_ASYNC_EVENT: | |
258 | stat = nvmet_set_feat_async_event(req, | |
259 | NVMET_DISC_AEN_CFG_OPTIONAL); | |
260 | break; | |
261 | default: | |
84faf42b CK |
262 | req->error_loc = |
263 | offsetof(struct nvme_common_command, cdw10); | |
6a8ec0ac JS |
264 | stat = NVME_SC_INVALID_FIELD | NVME_SC_DNR; |
265 | break; | |
266 | } | |
267 | ||
268 | nvmet_req_complete(req, stat); | |
269 | } | |
270 | ||
271 | static void nvmet_execute_disc_get_features(struct nvmet_req *req) | |
272 | { | |
b7c8f366 | 273 | u32 cdw10 = le32_to_cpu(req->cmd->common.cdw10); |
6a8ec0ac JS |
274 | u16 stat = 0; |
275 | ||
276 | switch (cdw10 & 0xff) { | |
277 | case NVME_FEAT_KATO: | |
278 | nvmet_get_feat_kato(req); | |
279 | break; | |
280 | case NVME_FEAT_ASYNC_EVENT: | |
281 | nvmet_get_feat_async_event(req); | |
282 | break; | |
283 | default: | |
84faf42b CK |
284 | req->error_loc = |
285 | offsetof(struct nvme_common_command, cdw10); | |
6a8ec0ac JS |
286 | stat = NVME_SC_INVALID_FIELD | NVME_SC_DNR; |
287 | break; | |
288 | } | |
289 | ||
290 | nvmet_req_complete(req, stat); | |
291 | } | |
292 | ||
64a0ca88 | 293 | u16 nvmet_parse_discovery_cmd(struct nvmet_req *req) |
a07b4970 CH |
294 | { |
295 | struct nvme_command *cmd = req->cmd; | |
296 | ||
a07b4970 | 297 | if (unlikely(!(req->sq->ctrl->csts & NVME_CSTS_RDY))) { |
4151dd9a PP |
298 | pr_err("got cmd %d while not ready\n", |
299 | cmd->common.opcode); | |
84faf42b CK |
300 | req->error_loc = |
301 | offsetof(struct nvme_common_command, opcode); | |
a07b4970 CH |
302 | return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; |
303 | } | |
304 | ||
305 | switch (cmd->common.opcode) { | |
6a8ec0ac JS |
306 | case nvme_admin_set_features: |
307 | req->execute = nvmet_execute_disc_set_features; | |
308 | req->data_len = 0; | |
309 | return 0; | |
310 | case nvme_admin_get_features: | |
311 | req->execute = nvmet_execute_disc_get_features; | |
312 | req->data_len = 0; | |
313 | return 0; | |
314 | case nvme_admin_async_event: | |
315 | req->execute = nvmet_execute_async_event; | |
316 | req->data_len = 0; | |
317 | return 0; | |
f9362ac1 JS |
318 | case nvme_admin_keep_alive: |
319 | req->execute = nvmet_execute_keep_alive; | |
320 | req->data_len = 0; | |
321 | return 0; | |
a07b4970 CH |
322 | case nvme_admin_get_log_page: |
323 | req->data_len = nvmet_get_log_page_len(cmd); | |
324 | ||
325 | switch (cmd->get_log_page.lid) { | |
326 | case NVME_LOG_DISC: | |
327 | req->execute = nvmet_execute_get_disc_log_page; | |
328 | return 0; | |
329 | default: | |
4151dd9a PP |
330 | pr_err("unsupported get_log_page lid %d\n", |
331 | cmd->get_log_page.lid); | |
84faf42b CK |
332 | req->error_loc = |
333 | offsetof(struct nvme_get_log_page_command, lid); | |
5bc373ff | 334 | return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; |
a07b4970 CH |
335 | } |
336 | case nvme_admin_identify: | |
0add5e8e | 337 | req->data_len = NVME_IDENTIFY_DATA_SIZE; |
986994a2 | 338 | switch (cmd->identify.cns) { |
e9c9346e | 339 | case NVME_ID_CNS_CTRL: |
a07b4970 CH |
340 | req->execute = |
341 | nvmet_execute_identify_disc_ctrl; | |
342 | return 0; | |
343 | default: | |
4151dd9a PP |
344 | pr_err("unsupported identify cns %d\n", |
345 | cmd->identify.cns); | |
84faf42b | 346 | req->error_loc = offsetof(struct nvme_identify, cns); |
a07b4970 CH |
347 | return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; |
348 | } | |
349 | default: | |
48440ab6 | 350 | pr_err("unhandled cmd %d\n", cmd->common.opcode); |
84faf42b | 351 | req->error_loc = offsetof(struct nvme_common_command, opcode); |
a07b4970 CH |
352 | return NVME_SC_INVALID_OPCODE | NVME_SC_DNR; |
353 | } | |
354 | ||
a07b4970 CH |
355 | } |
356 | ||
357 | int __init nvmet_init_discovery(void) | |
358 | { | |
359 | nvmet_disc_subsys = | |
360 | nvmet_subsys_alloc(NVME_DISC_SUBSYS_NAME, NVME_NQN_DISC); | |
361 | if (!nvmet_disc_subsys) | |
362 | return -ENOMEM; | |
363 | return 0; | |
364 | } | |
365 | ||
366 | void nvmet_exit_discovery(void) | |
367 | { | |
368 | nvmet_subsys_put(nvmet_disc_subsys); | |
369 | } |