1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (C) 2008-2012 Daisuke Aoyama <aoyama@peach.ne.jp>.
3 * Copyright (C) 2016 Intel Corporation.
4 * All rights reserved.
5 */
6
7 #include "spdk/stdinc.h"
8
9 #include "spdk/sock.h"
10 #include "spdk/scsi.h"
11
12 #include "spdk/log.h"
13
14 #include "iscsi/iscsi.h"
15 #include "iscsi/conn.h"
16 #include "iscsi/tgt_node.h"
17 #include "iscsi/portal_grp.h"
18 #include "iscsi/init_grp.h"
19 #include "iscsi/task.h"
20 #include "spdk/histogram_data.h"
21
22 #define MAX_TMPBUF 4096
23 #define MAX_MASKBUF 128
24
25
26 #define MAX_TMP_NAME_BUF (11 /* TargetName= */ + MAX_TARGET_NAME + 1 /* null */)
27 #define MAX_TMP_ADDR_BUF (14 /* TargetAddress= */ + MAX_PORTAL_ADDR + 1 /* : */ + \
28 MAX_PORTAL_PORT + 1 /* , */ + 10 /* max length of int in Decimal */ + 1 /* null */)
29
30 static bool
iscsi_ipv6_netmask_allow_addr(const char * netmask,const char * addr)31 iscsi_ipv6_netmask_allow_addr(const char *netmask, const char *addr)
32 {
33 struct in6_addr in6_mask;
34 struct in6_addr in6_addr;
35 char mask[MAX_MASKBUF];
36 const char *p;
37 size_t n;
38 int bits, bmask;
39 int i;
40
41 if (netmask[0] != '[') {
42 return false;
43 }
44 p = strchr(netmask, ']');
45 if (p == NULL) {
46 return false;
47 }
48 n = p - (netmask + 1);
49 if (n + 1 > sizeof mask) {
50 return false;
51 }
52
53 memcpy(mask, netmask + 1, n);
54 mask[n] = '\0';
55 p++;
56
57 if (p[0] == '/') {
58 bits = (int) strtol(p + 1, NULL, 10);
59 if (bits <= 0 || bits > 128) {
60 return false;
61 }
62 } else {
63 bits = 128;
64 }
65
66 #if 0
67 SPDK_DEBUGLOG(iscsi, "input %s\n", addr);
68 SPDK_DEBUGLOG(iscsi, "mask %s / %d\n", mask, bits);
69 #endif
70
71 /* presentation to network order binary */
72 if (inet_pton(AF_INET6, mask, &in6_mask) <= 0
73 || inet_pton(AF_INET6, addr, &in6_addr) <= 0) {
74 return false;
75 }
76
77 /* check 128bits */
78 for (i = 0; i < (bits / 8); i++) {
79 if (in6_mask.s6_addr[i] != in6_addr.s6_addr[i]) {
80 return false;
81 }
82 }
83 if (bits % 8) {
84 bmask = (0xffU << (8 - (bits % 8))) & 0xffU;
85 if ((in6_mask.s6_addr[i] & bmask) != (in6_addr.s6_addr[i] & bmask)) {
86 return false;
87 }
88 }
89
90 /* match */
91 return true;
92 }
93
94 static bool
iscsi_ipv4_netmask_allow_addr(const char * netmask,const char * addr)95 iscsi_ipv4_netmask_allow_addr(const char *netmask, const char *addr)
96 {
97 struct in_addr in4_mask;
98 struct in_addr in4_addr;
99 char mask[MAX_MASKBUF];
100 const char *p;
101 uint32_t bmask;
102 size_t n;
103 int bits;
104
105 p = strchr(netmask, '/');
106 if (p == NULL) {
107 p = netmask + strlen(netmask);
108 }
109 n = p - netmask;
110 if (n + 1 > sizeof mask) {
111 return false;
112 }
113
114 memcpy(mask, netmask, n);
115 mask[n] = '\0';
116
117 if (p[0] == '/') {
118 bits = (int) strtol(p + 1, NULL, 10);
119 if (bits <= 0 || bits > 32) {
120 return false;
121 }
122 } else {
123 bits = 32;
124 }
125
126 /* presentation to network order binary */
127 if (inet_pton(AF_INET, mask, &in4_mask) <= 0
128 || inet_pton(AF_INET, addr, &in4_addr) <= 0) {
129 return false;
130 }
131
132 /* check 32bits */
133 bmask = (0xffffffffU << (32 - bits)) & 0xffffffffU;
134 if ((ntohl(in4_mask.s_addr) & bmask) != (ntohl(in4_addr.s_addr) & bmask)) {
135 return false;
136 }
137
138 /* match */
139 return true;
140 }
141
142 static bool
iscsi_netmask_allow_addr(const char * netmask,const char * addr)143 iscsi_netmask_allow_addr(const char *netmask, const char *addr)
144 {
145 if (netmask == NULL || addr == NULL) {
146 return false;
147 }
148 if (strcasecmp(netmask, "ANY") == 0) {
149 return true;
150 }
151 if (netmask[0] == '[') {
152 /* IPv6 */
153 if (iscsi_ipv6_netmask_allow_addr(netmask, addr)) {
154 return true;
155 }
156 } else {
157 /* IPv4 */
158 if (iscsi_ipv4_netmask_allow_addr(netmask, addr)) {
159 return true;
160 }
161 }
162 return false;
163 }
164
165 static bool
iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp * igp,const char * addr)166 iscsi_init_grp_allow_addr(struct spdk_iscsi_init_grp *igp,
167 const char *addr)
168 {
169 struct spdk_iscsi_initiator_netmask *imask;
170
171 TAILQ_FOREACH(imask, &igp->netmask_head, tailq) {
172 SPDK_DEBUGLOG(iscsi, "netmask=%s, addr=%s\n",
173 imask->mask, addr);
174 if (iscsi_netmask_allow_addr(imask->mask, addr)) {
175 return true;
176 }
177 }
178 return false;
179 }
180
181 static int
iscsi_init_grp_allow_iscsi_name(struct spdk_iscsi_init_grp * igp,const char * iqn,bool * result)182 iscsi_init_grp_allow_iscsi_name(struct spdk_iscsi_init_grp *igp,
183 const char *iqn, bool *result)
184 {
185 struct spdk_iscsi_initiator_name *iname;
186
187 TAILQ_FOREACH(iname, &igp->initiator_head, tailq) {
188 /* denied if iqn is matched */
189 if ((iname->name[0] == '!')
190 && (strcasecmp(&iname->name[1], "ANY") == 0
191 || strcasecmp(&iname->name[1], iqn) == 0)) {
192 *result = false;
193 return 0;
194 }
195 /* allowed if iqn is matched */
196 if (strcasecmp(iname->name, "ANY") == 0
197 || strcasecmp(iname->name, iqn) == 0) {
198 *result = true;
199 return 0;
200 }
201 }
202 return -1;
203 }
204
205 static struct spdk_iscsi_pg_map *iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target,
206 struct spdk_iscsi_portal_grp *pg);
207
208 bool
iscsi_tgt_node_access(struct spdk_iscsi_conn * conn,struct spdk_iscsi_tgt_node * target,const char * iqn,const char * addr)209 iscsi_tgt_node_access(struct spdk_iscsi_conn *conn,
210 struct spdk_iscsi_tgt_node *target, const char *iqn, const char *addr)
211 {
212 struct spdk_iscsi_portal_grp *pg;
213 struct spdk_iscsi_pg_map *pg_map;
214 struct spdk_iscsi_ig_map *ig_map;
215 int rc;
216 bool allowed = false;
217
218 if (conn == NULL || target == NULL || iqn == NULL || addr == NULL) {
219 return false;
220 }
221 pg = conn->portal->group;
222
223 SPDK_DEBUGLOG(iscsi, "pg=%d, iqn=%s, addr=%s\n",
224 pg->tag, iqn, addr);
225 pg_map = iscsi_tgt_node_find_pg_map(target, pg);
226 if (pg_map == NULL) {
227 return false;
228 }
229 TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
230 rc = iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &allowed);
231 if (rc == 0) {
232 if (allowed == false) {
233 goto denied;
234 } else {
235 if (iscsi_init_grp_allow_addr(ig_map->ig, addr)) {
236 return true;
237 }
238 }
239 } else {
240 /* netmask is denied in this initiator group */
241 }
242 }
243
244 denied:
245 SPDK_DEBUGLOG(iscsi, "access denied from %s (%s) to %s (%s:%s,%d)\n",
246 iqn, addr, target->name, conn->portal_host,
247 conn->portal_port, conn->pg_tag);
248 return false;
249 }
250
251 static bool
iscsi_tgt_node_allow_iscsi_name(struct spdk_iscsi_tgt_node * target,const char * iqn)252 iscsi_tgt_node_allow_iscsi_name(struct spdk_iscsi_tgt_node *target, const char *iqn)
253 {
254 struct spdk_iscsi_pg_map *pg_map;
255 struct spdk_iscsi_ig_map *ig_map;
256 int rc;
257 bool result = false;
258
259 if (target == NULL || iqn == NULL) {
260 return false;
261 }
262
263 TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
264 TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
265 rc = iscsi_init_grp_allow_iscsi_name(ig_map->ig, iqn, &result);
266 if (rc == 0) {
267 return result;
268 }
269 }
270 }
271
272 return false;
273 }
274
275 static bool
iscsi_copy_str(char * data,int * total,int alloc_len,int * previous_completed_len,int expected_size,char * src)276 iscsi_copy_str(char *data, int *total, int alloc_len,
277 int *previous_completed_len, int expected_size, char *src)
278 {
279 int len = 0;
280
281 assert(*previous_completed_len >= 0);
282
283 if (alloc_len - *total < 1) {
284 return true;
285 }
286
287 if (*previous_completed_len < expected_size) {
288 len = spdk_min(alloc_len - *total, expected_size - *previous_completed_len);
289 memcpy((char *)data + *total, src + *previous_completed_len, len);
290 *total += len;
291 *previous_completed_len = 0;
292 } else {
293 *previous_completed_len -= expected_size;
294 }
295
296 return false;
297 }
298
299 static int
iscsi_send_tgt_portals(struct spdk_iscsi_conn * conn,struct spdk_iscsi_tgt_node * target,uint8_t * data,int alloc_len,int total,int * previous_completed_len,bool * no_buf_space)300 iscsi_send_tgt_portals(struct spdk_iscsi_conn *conn,
301 struct spdk_iscsi_tgt_node *target,
302 uint8_t *data, int alloc_len, int total,
303 int *previous_completed_len, bool *no_buf_space)
304 {
305 char buf[MAX_TARGET_ADDR + 2];
306 struct spdk_iscsi_portal_grp *pg;
307 struct spdk_iscsi_pg_map *pg_map;
308 struct spdk_iscsi_portal *p;
309 char *host;
310 char tmp_buf[MAX_TMP_ADDR_BUF];
311 int len;
312
313 TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
314 pg = pg_map->pg;
315
316 if (pg->is_private) {
317 /* Skip the private portal group. Portals in the private portal group
318 * will be returned only by temporary login redirection responses.
319 */
320 continue;
321 }
322
323 TAILQ_FOREACH(p, &pg->head, per_pg_tailq) {
324 host = p->host;
325 /* wildcard? */
326 if (strcasecmp(host, "[::]") == 0 || strcasecmp(host, "0.0.0.0") == 0) {
327 if (spdk_sock_is_ipv6(conn->sock)) {
328 snprintf(buf, sizeof buf, "[%s]", conn->target_addr);
329 host = buf;
330 } else if (spdk_sock_is_ipv4(conn->sock)) {
331 snprintf(buf, sizeof buf, "%s", conn->target_addr);
332 host = buf;
333 } else {
334 /* skip portal for the family */
335 continue;
336 }
337 }
338 SPDK_DEBUGLOG(iscsi, "TargetAddress=%s:%s,%d\n",
339 host, p->port, pg->tag);
340
341 memset(tmp_buf, 0, sizeof(tmp_buf));
342 /* Calculate the whole string size */
343 len = snprintf(NULL, 0, "TargetAddress=%s:%s,%d", host, p->port, pg->tag);
344 assert(len < MAX_TMPBUF);
345
346 /* string contents are not fully copied */
347 if (*previous_completed_len < len) {
348 /* Copy the string into the temporary buffer */
349 snprintf(tmp_buf, len + 1, "TargetAddress=%s:%s,%d", host, p->port, pg->tag);
350 }
351
352 *no_buf_space = iscsi_copy_str(data, &total, alloc_len, previous_completed_len,
353 len + 1, tmp_buf);
354 if (*no_buf_space) {
355 break;
356 }
357 }
358 }
359
360 return total;
361 }
362
363 int
iscsi_send_tgts(struct spdk_iscsi_conn * conn,const char * iiqn,const char * tiqn,uint8_t * data,int alloc_len,int data_len)364 iscsi_send_tgts(struct spdk_iscsi_conn *conn, const char *iiqn,
365 const char *tiqn, uint8_t *data, int alloc_len, int data_len)
366 {
367 struct spdk_iscsi_tgt_node *target;
368 int total;
369 int len;
370 int rc;
371 int previous_completed_size = 0;
372 bool no_buf_space = false;
373 char tmp_buf[MAX_TMP_NAME_BUF];
374
375 if (conn == NULL) {
376 return 0;
377 }
378 previous_completed_size = conn->send_tgt_completed_size;
379
380 total = data_len;
381 if (alloc_len < 1) {
382 return 0;
383 }
384 if (total >= alloc_len) {
385 total = alloc_len;
386 data[total - 1] = '\0';
387 return total;
388 }
389
390 pthread_mutex_lock(&g_iscsi.mutex);
391 TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
392 if (strcasecmp(tiqn, "ALL") != 0
393 && strcasecmp(tiqn, target->name) != 0) {
394 continue;
395 }
396 rc = iscsi_tgt_node_allow_iscsi_name(target, iiqn);
397 if (rc == 0) {
398 continue;
399 }
400
401 memset(tmp_buf, 0, sizeof(tmp_buf));
402 /* Calculate the whole string size */
403 len = snprintf(NULL, 0, "TargetName=%s", target->name);
404 assert(len < MAX_TMPBUF);
405
406 /* String contents are not copied */
407 if (previous_completed_size < len) {
408 /* Copy the string into the temporary buffer */
409 snprintf(tmp_buf, len + 1, "TargetName=%s", target->name);
410 }
411
412 no_buf_space = iscsi_copy_str(data, &total, alloc_len, &previous_completed_size,
413 len + 1, tmp_buf);
414 if (no_buf_space) {
415 break;
416 }
417
418 total = iscsi_send_tgt_portals(conn, target, data, alloc_len, total,
419 &previous_completed_size, &no_buf_space);
420 if (no_buf_space) {
421 break;
422 }
423 }
424 pthread_mutex_unlock(&g_iscsi.mutex);
425
426 /* Only set it when it is not successfully completed */
427 if (no_buf_space) {
428 conn->send_tgt_completed_size += total;
429 } else {
430 conn->send_tgt_completed_size = 0;
431 }
432
433 return total;
434 }
435
436 struct spdk_iscsi_tgt_node *
iscsi_find_tgt_node(const char * target_name)437 iscsi_find_tgt_node(const char *target_name)
438 {
439 struct spdk_iscsi_tgt_node *target;
440
441 if (target_name == NULL) {
442 return NULL;
443 }
444 TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
445 if (strcasecmp(target_name, target->name) == 0) {
446 return target;
447 }
448 }
449 return NULL;
450 }
451
452 static int
iscsi_tgt_node_register(struct spdk_iscsi_tgt_node * target)453 iscsi_tgt_node_register(struct spdk_iscsi_tgt_node *target)
454 {
455 pthread_mutex_lock(&g_iscsi.mutex);
456
457 if (iscsi_find_tgt_node(target->name) != NULL) {
458 pthread_mutex_unlock(&g_iscsi.mutex);
459 return -EEXIST;
460 }
461
462 TAILQ_INSERT_TAIL(&g_iscsi.target_head, target, tailq);
463
464 pthread_mutex_unlock(&g_iscsi.mutex);
465 return 0;
466 }
467
468 static int
iscsi_tgt_node_unregister(struct spdk_iscsi_tgt_node * target)469 iscsi_tgt_node_unregister(struct spdk_iscsi_tgt_node *target)
470 {
471 struct spdk_iscsi_tgt_node *t;
472
473 TAILQ_FOREACH(t, &g_iscsi.target_head, tailq) {
474 if (t == target) {
475 TAILQ_REMOVE(&g_iscsi.target_head, t, tailq);
476 return 0;
477 }
478 }
479
480 return -1;
481 }
482
483 static struct spdk_iscsi_ig_map *
iscsi_pg_map_find_ig_map(struct spdk_iscsi_pg_map * pg_map,struct spdk_iscsi_init_grp * ig)484 iscsi_pg_map_find_ig_map(struct spdk_iscsi_pg_map *pg_map,
485 struct spdk_iscsi_init_grp *ig)
486 {
487 struct spdk_iscsi_ig_map *ig_map;
488
489 TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
490 if (ig_map->ig == ig) {
491 return ig_map;
492 }
493 }
494
495 return NULL;
496 }
497
498 static struct spdk_iscsi_ig_map *
iscsi_pg_map_add_ig_map(struct spdk_iscsi_pg_map * pg_map,struct spdk_iscsi_init_grp * ig)499 iscsi_pg_map_add_ig_map(struct spdk_iscsi_pg_map *pg_map,
500 struct spdk_iscsi_init_grp *ig)
501 {
502 struct spdk_iscsi_ig_map *ig_map;
503
504 if (iscsi_pg_map_find_ig_map(pg_map, ig) != NULL) {
505 return NULL;
506 }
507
508 ig_map = malloc(sizeof(*ig_map));
509 if (ig_map == NULL) {
510 return NULL;
511 }
512
513 ig_map->ig = ig;
514 ig->ref++;
515 pg_map->num_ig_maps++;
516 TAILQ_INSERT_TAIL(&pg_map->ig_map_head, ig_map, tailq);
517
518 return ig_map;
519 }
520
521 static void
_iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map * pg_map,struct spdk_iscsi_ig_map * ig_map)522 _iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map,
523 struct spdk_iscsi_ig_map *ig_map)
524 {
525 TAILQ_REMOVE(&pg_map->ig_map_head, ig_map, tailq);
526 pg_map->num_ig_maps--;
527 ig_map->ig->ref--;
528 free(ig_map);
529 }
530
531 static int
iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map * pg_map,struct spdk_iscsi_init_grp * ig)532 iscsi_pg_map_delete_ig_map(struct spdk_iscsi_pg_map *pg_map,
533 struct spdk_iscsi_init_grp *ig)
534 {
535 struct spdk_iscsi_ig_map *ig_map;
536
537 ig_map = iscsi_pg_map_find_ig_map(pg_map, ig);
538 if (ig_map == NULL) {
539 return -ENOENT;
540 }
541
542 _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
543 return 0;
544 }
545
546 static void
iscsi_pg_map_delete_all_ig_maps(struct spdk_iscsi_pg_map * pg_map)547 iscsi_pg_map_delete_all_ig_maps(struct spdk_iscsi_pg_map *pg_map)
548 {
549 struct spdk_iscsi_ig_map *ig_map, *tmp;
550
551 TAILQ_FOREACH_SAFE(ig_map, &pg_map->ig_map_head, tailq, tmp) {
552 _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
553 }
554 }
555
556 static struct spdk_iscsi_pg_map *
iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node * target,struct spdk_iscsi_portal_grp * pg)557 iscsi_tgt_node_find_pg_map(struct spdk_iscsi_tgt_node *target,
558 struct spdk_iscsi_portal_grp *pg)
559 {
560 struct spdk_iscsi_pg_map *pg_map;
561
562 TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
563 if (pg_map->pg == pg) {
564 return pg_map;
565 }
566 }
567
568 return NULL;
569 }
570
571 static struct spdk_iscsi_pg_map *
iscsi_tgt_node_add_pg_map(struct spdk_iscsi_tgt_node * target,struct spdk_iscsi_portal_grp * pg)572 iscsi_tgt_node_add_pg_map(struct spdk_iscsi_tgt_node *target,
573 struct spdk_iscsi_portal_grp *pg)
574 {
575 struct spdk_iscsi_pg_map *pg_map;
576 char port_name[MAX_TMPBUF];
577 int rc;
578
579 if (iscsi_tgt_node_find_pg_map(target, pg) != NULL) {
580 return NULL;
581 }
582
583 if (target->num_pg_maps >= SPDK_SCSI_DEV_MAX_PORTS) {
584 SPDK_ERRLOG("Number of PG maps is more than allowed (max=%d)\n",
585 SPDK_SCSI_DEV_MAX_PORTS);
586 return NULL;
587 }
588
589 pg_map = calloc(1, sizeof(*pg_map));
590 if (pg_map == NULL) {
591 return NULL;
592 }
593
594 snprintf(port_name, sizeof(port_name), "%s,t,0x%4.4x",
595 spdk_scsi_dev_get_name(target->dev), pg->tag);
596 rc = spdk_scsi_dev_add_port(target->dev, pg->tag, port_name);
597 if (rc != 0) {
598 free(pg_map);
599 return NULL;
600 }
601
602 TAILQ_INIT(&pg_map->ig_map_head);
603 pg_map->num_ig_maps = 0;
604 pg->ref++;
605 pg_map->pg = pg;
606 target->num_pg_maps++;
607 TAILQ_INSERT_TAIL(&target->pg_map_head, pg_map, tailq);
608
609 return pg_map;
610 }
611
612 static void
_iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node * target,struct spdk_iscsi_pg_map * pg_map)613 _iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
614 struct spdk_iscsi_pg_map *pg_map)
615 {
616 TAILQ_REMOVE(&target->pg_map_head, pg_map, tailq);
617 target->num_pg_maps--;
618 pg_map->pg->ref--;
619
620 spdk_scsi_dev_delete_port(target->dev, pg_map->pg->tag);
621
622 free(pg_map);
623 }
624
625 static int
iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node * target,struct spdk_iscsi_portal_grp * pg)626 iscsi_tgt_node_delete_pg_map(struct spdk_iscsi_tgt_node *target,
627 struct spdk_iscsi_portal_grp *pg)
628 {
629 struct spdk_iscsi_pg_map *pg_map;
630
631 pg_map = iscsi_tgt_node_find_pg_map(target, pg);
632 if (pg_map == NULL) {
633 return -ENOENT;
634 }
635
636 if (pg_map->num_ig_maps > 0) {
637 SPDK_DEBUGLOG(iscsi, "delete %d ig_maps forcefully\n",
638 pg_map->num_ig_maps);
639 }
640
641 iscsi_pg_map_delete_all_ig_maps(pg_map);
642 _iscsi_tgt_node_delete_pg_map(target, pg_map);
643 return 0;
644 }
645
646 static void
iscsi_tgt_node_delete_ig_maps(struct spdk_iscsi_tgt_node * target,struct spdk_iscsi_init_grp * ig)647 iscsi_tgt_node_delete_ig_maps(struct spdk_iscsi_tgt_node *target,
648 struct spdk_iscsi_init_grp *ig)
649 {
650 struct spdk_iscsi_pg_map *pg_map, *tmp;
651
652 TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) {
653 iscsi_pg_map_delete_ig_map(pg_map, ig);
654 if (pg_map->num_ig_maps == 0) {
655 _iscsi_tgt_node_delete_pg_map(target, pg_map);
656 }
657 }
658 }
659
660 static void
iscsi_tgt_node_delete_all_pg_maps(struct spdk_iscsi_tgt_node * target)661 iscsi_tgt_node_delete_all_pg_maps(struct spdk_iscsi_tgt_node *target)
662 {
663 struct spdk_iscsi_pg_map *pg_map, *tmp;
664
665 TAILQ_FOREACH_SAFE(pg_map, &target->pg_map_head, tailq, tmp) {
666 iscsi_pg_map_delete_all_ig_maps(pg_map);
667 _iscsi_tgt_node_delete_pg_map(target, pg_map);
668 }
669 }
670
671 static void
_iscsi_tgt_node_destruct(void * cb_arg,int rc)672 _iscsi_tgt_node_destruct(void *cb_arg, int rc)
673 {
674 struct spdk_iscsi_tgt_node *target = cb_arg;
675 iscsi_tgt_node_destruct_cb destruct_cb_fn = target->destruct_cb_fn;
676 void *destruct_cb_arg = target->destruct_cb_arg;
677
678 if (rc != 0) {
679 if (destruct_cb_fn) {
680 destruct_cb_fn(destruct_cb_arg, rc);
681 }
682 return;
683 }
684
685 pthread_mutex_lock(&g_iscsi.mutex);
686 iscsi_tgt_node_delete_all_pg_maps(target);
687 pthread_mutex_unlock(&g_iscsi.mutex);
688
689 pthread_mutex_destroy(&target->mutex);
690
691 spdk_histogram_data_free(target->histogram);
692
693 free(target);
694
695 if (destruct_cb_fn) {
696 destruct_cb_fn(destruct_cb_arg, 0);
697 }
698 }
699
700 static int
iscsi_tgt_node_check_active_conns(void * arg)701 iscsi_tgt_node_check_active_conns(void *arg)
702 {
703 struct spdk_iscsi_tgt_node *target = arg;
704
705 if (iscsi_get_active_conns(target) != 0) {
706 return SPDK_POLLER_BUSY;
707 }
708
709 spdk_poller_unregister(&target->destruct_poller);
710
711 spdk_scsi_dev_destruct(target->dev, _iscsi_tgt_node_destruct, target);
712
713 return SPDK_POLLER_BUSY;
714 }
715
716 static void
iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node * target,iscsi_tgt_node_destruct_cb cb_fn,void * cb_arg)717 iscsi_tgt_node_destruct(struct spdk_iscsi_tgt_node *target,
718 iscsi_tgt_node_destruct_cb cb_fn, void *cb_arg)
719 {
720 if (target == NULL) {
721 if (cb_fn) {
722 cb_fn(cb_arg, -ENOENT);
723 }
724 return;
725 }
726
727 if (target->destructed) {
728 SPDK_ERRLOG("Destructing %s is already started\n", target->name);
729 if (cb_fn) {
730 cb_fn(cb_arg, -EBUSY);
731 }
732 return;
733 }
734
735 target->destructed = true;
736 target->destruct_cb_fn = cb_fn;
737 target->destruct_cb_arg = cb_arg;
738
739 iscsi_conns_request_logout(target, -1);
740
741 if (iscsi_get_active_conns(target) != 0) {
742 target->destruct_poller = SPDK_POLLER_REGISTER(iscsi_tgt_node_check_active_conns,
743 target, 10);
744 } else {
745 spdk_scsi_dev_destruct(target->dev, _iscsi_tgt_node_destruct, target);
746 }
747
748 }
749
750 static int
iscsi_tgt_node_delete_pg_ig_map(struct spdk_iscsi_tgt_node * target,int pg_tag,int ig_tag)751 iscsi_tgt_node_delete_pg_ig_map(struct spdk_iscsi_tgt_node *target,
752 int pg_tag, int ig_tag)
753 {
754 struct spdk_iscsi_portal_grp *pg;
755 struct spdk_iscsi_init_grp *ig;
756 struct spdk_iscsi_pg_map *pg_map;
757 struct spdk_iscsi_ig_map *ig_map;
758
759 pg = iscsi_portal_grp_find_by_tag(pg_tag);
760 if (pg == NULL) {
761 SPDK_ERRLOG("%s: PortalGroup%d not found\n", target->name, pg_tag);
762 return -ENOENT;
763 }
764 ig = iscsi_init_grp_find_by_tag(ig_tag);
765 if (ig == NULL) {
766 SPDK_ERRLOG("%s: InitiatorGroup%d not found\n", target->name, ig_tag);
767 return -ENOENT;
768 }
769
770 pg_map = iscsi_tgt_node_find_pg_map(target, pg);
771 if (pg_map == NULL) {
772 SPDK_ERRLOG("%s: PortalGroup%d is not mapped\n", target->name, pg_tag);
773 return -ENOENT;
774 }
775 ig_map = iscsi_pg_map_find_ig_map(pg_map, ig);
776 if (ig_map == NULL) {
777 SPDK_ERRLOG("%s: InitiatorGroup%d is not mapped\n", target->name, pg_tag);
778 return -ENOENT;
779 }
780
781 _iscsi_pg_map_delete_ig_map(pg_map, ig_map);
782 if (pg_map->num_ig_maps == 0) {
783 _iscsi_tgt_node_delete_pg_map(target, pg_map);
784 }
785
786 return 0;
787 }
788
789 static int
iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node * target,int pg_tag,int ig_tag)790 iscsi_tgt_node_add_pg_ig_map(struct spdk_iscsi_tgt_node *target,
791 int pg_tag, int ig_tag)
792 {
793 struct spdk_iscsi_portal_grp *pg;
794 struct spdk_iscsi_pg_map *pg_map;
795 struct spdk_iscsi_init_grp *ig;
796 struct spdk_iscsi_ig_map *ig_map;
797 bool new_pg_map = false;
798
799 pg = iscsi_portal_grp_find_by_tag(pg_tag);
800 if (pg == NULL) {
801 SPDK_ERRLOG("%s: PortalGroup%d not found\n", target->name, pg_tag);
802 return -ENOENT;
803 }
804 ig = iscsi_init_grp_find_by_tag(ig_tag);
805 if (ig == NULL) {
806 SPDK_ERRLOG("%s: InitiatorGroup%d not found\n", target->name, ig_tag);
807 return -ENOENT;
808 }
809
810 /* get existing pg_map or create new pg_map and add it to target */
811 pg_map = iscsi_tgt_node_find_pg_map(target, pg);
812 if (pg_map == NULL) {
813 pg_map = iscsi_tgt_node_add_pg_map(target, pg);
814 if (pg_map == NULL) {
815 goto failed;
816 }
817 new_pg_map = true;
818 }
819
820 /* create new ig_map and add it to pg_map */
821 ig_map = iscsi_pg_map_add_ig_map(pg_map, ig);
822 if (ig_map == NULL) {
823 goto failed;
824 }
825
826 return 0;
827
828 failed:
829 if (new_pg_map) {
830 _iscsi_tgt_node_delete_pg_map(target, pg_map);
831 }
832
833 return -1;
834 }
835
836 int
iscsi_target_node_add_pg_ig_maps(struct spdk_iscsi_tgt_node * target,int * pg_tag_list,int * ig_tag_list,uint16_t num_maps)837 iscsi_target_node_add_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
838 int *pg_tag_list, int *ig_tag_list, uint16_t num_maps)
839 {
840 uint16_t i;
841 int rc;
842
843 pthread_mutex_lock(&g_iscsi.mutex);
844 for (i = 0; i < num_maps; i++) {
845 rc = iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i],
846 ig_tag_list[i]);
847 if (rc != 0) {
848 SPDK_ERRLOG("could not add map to target\n");
849 goto invalid;
850 }
851 }
852 pthread_mutex_unlock(&g_iscsi.mutex);
853 return 0;
854
855 invalid:
856 for (; i > 0; --i) {
857 iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i - 1],
858 ig_tag_list[i - 1]);
859 }
860 pthread_mutex_unlock(&g_iscsi.mutex);
861 return -1;
862 }
863
864 int
iscsi_target_node_remove_pg_ig_maps(struct spdk_iscsi_tgt_node * target,int * pg_tag_list,int * ig_tag_list,uint16_t num_maps)865 iscsi_target_node_remove_pg_ig_maps(struct spdk_iscsi_tgt_node *target,
866 int *pg_tag_list, int *ig_tag_list, uint16_t num_maps)
867 {
868 uint16_t i;
869 int rc;
870
871 pthread_mutex_lock(&g_iscsi.mutex);
872 for (i = 0; i < num_maps; i++) {
873 rc = iscsi_tgt_node_delete_pg_ig_map(target, pg_tag_list[i],
874 ig_tag_list[i]);
875 if (rc != 0) {
876 SPDK_ERRLOG("could not delete map from target\n");
877 goto invalid;
878 }
879 }
880 pthread_mutex_unlock(&g_iscsi.mutex);
881 return 0;
882
883 invalid:
884 for (; i > 0; --i) {
885 rc = iscsi_tgt_node_add_pg_ig_map(target, pg_tag_list[i - 1],
886 ig_tag_list[i - 1]);
887 if (rc != 0) {
888 iscsi_tgt_node_delete_all_pg_maps(target);
889 break;
890 }
891 }
892 pthread_mutex_unlock(&g_iscsi.mutex);
893 return -1;
894 }
895
896 int
iscsi_tgt_node_redirect(struct spdk_iscsi_tgt_node * target,int pg_tag,const char * host,const char * port)897 iscsi_tgt_node_redirect(struct spdk_iscsi_tgt_node *target, int pg_tag,
898 const char *host, const char *port)
899 {
900 struct spdk_iscsi_portal_grp *pg;
901 struct spdk_iscsi_pg_map *pg_map;
902 struct sockaddr_storage sa;
903
904 if (target == NULL) {
905 return -EINVAL;
906 }
907
908 pg = iscsi_portal_grp_find_by_tag(pg_tag);
909 if (pg == NULL) {
910 SPDK_ERRLOG("Portal group %d is not found.\n", pg_tag);
911 return -EINVAL;
912 }
913
914 if (pg->is_private) {
915 SPDK_ERRLOG("Portal group %d is not public portal group.\n", pg_tag);
916 return -EINVAL;
917 }
918
919 pg_map = iscsi_tgt_node_find_pg_map(target, pg);
920 if (pg_map == NULL) {
921 SPDK_ERRLOG("Portal group %d is not mapped.\n", pg_tag);
922 return -EINVAL;
923 }
924
925 if (host == NULL && port == NULL) {
926 /* Clear redirect setting. */
927 memset(pg_map->redirect_host, 0, MAX_PORTAL_ADDR + 1);
928 memset(pg_map->redirect_port, 0, MAX_PORTAL_PORT + 1);
929 } else {
930 if (iscsi_parse_redirect_addr(&sa, host, port) != 0) {
931 SPDK_ERRLOG("IP address-port pair is not valid.\n");
932 return -EINVAL;
933 }
934
935 if (iscsi_portal_grp_find_portal_by_addr(pg, port, host) != NULL) {
936 SPDK_ERRLOG("IP address-port pair must be chosen from a "
937 "different private portal group\n");
938 return -EINVAL;
939 }
940
941 snprintf(pg_map->redirect_host, MAX_PORTAL_ADDR + 1, "%s", host);
942 snprintf(pg_map->redirect_port, MAX_PORTAL_PORT + 1, "%s", port);
943 }
944
945 return 0;
946 }
947
948 bool
iscsi_tgt_node_is_redirected(struct spdk_iscsi_conn * conn,struct spdk_iscsi_tgt_node * target,char * buf,int buf_len)949 iscsi_tgt_node_is_redirected(struct spdk_iscsi_conn *conn,
950 struct spdk_iscsi_tgt_node *target,
951 char *buf, int buf_len)
952 {
953 struct spdk_iscsi_pg_map *pg_map;
954
955 if (conn == NULL || target == NULL || buf == NULL || buf_len == 0) {
956 return false;
957 }
958
959 pg_map = iscsi_tgt_node_find_pg_map(target, conn->portal->group);
960 if (pg_map == NULL) {
961 return false;
962 }
963
964 if (pg_map->redirect_host[0] == '\0' || pg_map->redirect_port[0] == '\0') {
965 return false;
966 }
967
968 snprintf(buf, buf_len, "%s:%s", pg_map->redirect_host, pg_map->redirect_port);
969
970 return true;
971 }
972
973 static int
check_iscsi_name(const char * name)974 check_iscsi_name(const char *name)
975 {
976 const unsigned char *up = (const unsigned char *) name;
977 size_t n;
978
979 /* valid iSCSI name no larger than 223 bytes */
980 if (strlen(name) > MAX_TARGET_NAME) {
981 return -1;
982 }
983
984 /* valid iSCSI name? */
985 for (n = 0; up[n] != 0; n++) {
986 if (up[n] > 0x00U && up[n] <= 0x2cU) {
987 return -1;
988 }
989 if (up[n] == 0x2fU) {
990 return -1;
991 }
992 if (up[n] >= 0x3bU && up[n] <= 0x40U) {
993 return -1;
994 }
995 if (up[n] >= 0x5bU && up[n] <= 0x60U) {
996 return -1;
997 }
998 if (up[n] >= 0x7bU && up[n] <= 0x7fU) {
999 return -1;
1000 }
1001 if (isspace(up[n])) {
1002 return -1;
1003 }
1004 }
1005 /* valid format? */
1006 if (strncasecmp(name, "iqn.", 4) == 0) {
1007 /* iqn.YYYY-MM.reversed.domain.name */
1008 if (!isdigit(up[4]) || !isdigit(up[5]) || !isdigit(up[6])
1009 || !isdigit(up[7]) || up[8] != '-' || !isdigit(up[9])
1010 || !isdigit(up[10]) || up[11] != '.') {
1011 SPDK_ERRLOG("invalid iqn format. "
1012 "expect \"iqn.YYYY-MM.reversed.domain.name\"\n");
1013 return -1;
1014 }
1015 } else if (strncasecmp(name, "eui.", 4) == 0) {
1016 /* EUI-64 -> 16bytes */
1017 /* XXX */
1018 } else if (strncasecmp(name, "naa.", 4) == 0) {
1019 /* 64bit -> 16bytes, 128bit -> 32bytes */
1020 /* XXX */
1021 }
1022 /* OK */
1023 return 0;
1024 }
1025
1026 bool
iscsi_check_chap_params(bool disable,bool require,bool mutual,int group)1027 iscsi_check_chap_params(bool disable, bool require, bool mutual, int group)
1028 {
1029 if (group < 0) {
1030 SPDK_ERRLOG("Invalid auth group ID (%d)\n", group);
1031 return false;
1032 }
1033 if ((!disable && !require && !mutual) || /* Auto */
1034 (disable && !require && !mutual) || /* None */
1035 (!disable && require && !mutual) || /* CHAP */
1036 (!disable && require && mutual)) { /* CHAP Mutual */
1037 return true;
1038 }
1039 SPDK_ERRLOG("Invalid combination of CHAP params (d=%d,r=%d,m=%d)\n",
1040 disable, require, mutual);
1041 return false;
1042 }
1043
iscsi_tgt_node_construct(int target_index,const char * name,const char * alias,int * pg_tag_list,int * ig_tag_list,uint16_t num_maps,const char * bdev_name_list[],int * lun_id_list,int num_luns,int queue_depth,bool disable_chap,bool require_chap,bool mutual_chap,int chap_group,bool header_digest,bool data_digest)1044 struct spdk_iscsi_tgt_node *iscsi_tgt_node_construct(int target_index,
1045 const char *name, const char *alias,
1046 int *pg_tag_list, int *ig_tag_list, uint16_t num_maps,
1047 const char *bdev_name_list[], int *lun_id_list, int num_luns,
1048 int queue_depth,
1049 bool disable_chap, bool require_chap, bool mutual_chap, int chap_group,
1050 bool header_digest, bool data_digest)
1051 {
1052 char fullname[MAX_TMPBUF];
1053 struct spdk_iscsi_tgt_node *target;
1054 int rc;
1055
1056 if (!iscsi_check_chap_params(disable_chap, require_chap,
1057 mutual_chap, chap_group)) {
1058 return NULL;
1059 }
1060
1061 if (num_maps == 0) {
1062 SPDK_ERRLOG("num_maps = 0\n");
1063 return NULL;
1064 }
1065
1066 if (name == NULL) {
1067 SPDK_ERRLOG("TargetName not found\n");
1068 return NULL;
1069 }
1070
1071 if (strncasecmp(name, "iqn.", 4) != 0
1072 && strncasecmp(name, "eui.", 4) != 0
1073 && strncasecmp(name, "naa.", 4) != 0) {
1074 snprintf(fullname, sizeof(fullname), "%s:%s", g_iscsi.nodebase, name);
1075 } else {
1076 snprintf(fullname, sizeof(fullname), "%s", name);
1077 }
1078
1079 if (check_iscsi_name(fullname) != 0) {
1080 SPDK_ERRLOG("TargetName %s contains an invalid character or format.\n",
1081 name);
1082 return NULL;
1083 }
1084
1085 target = calloc(1, sizeof(*target));
1086 if (!target) {
1087 SPDK_ERRLOG("could not allocate target\n");
1088 return NULL;
1089 }
1090
1091 rc = pthread_mutex_init(&target->mutex, NULL);
1092 if (rc != 0) {
1093 SPDK_ERRLOG("tgt_node%d: mutex_init() failed\n", target->num);
1094 iscsi_tgt_node_destruct(target, NULL, NULL);
1095 return NULL;
1096 }
1097
1098 target->num = target_index;
1099
1100 memcpy(target->name, fullname, strlen(fullname));
1101
1102 if (alias != NULL) {
1103 if (strlen(alias) > MAX_TARGET_NAME) {
1104 iscsi_tgt_node_destruct(target, NULL, NULL);
1105 return NULL;
1106 }
1107 memcpy(target->alias, alias, strlen(alias));
1108 }
1109
1110 target->dev = spdk_scsi_dev_construct(fullname, bdev_name_list, lun_id_list, num_luns,
1111 SPDK_SPC_PROTOCOL_IDENTIFIER_ISCSI, NULL, NULL);
1112 if (!target->dev) {
1113 SPDK_ERRLOG("Could not construct SCSI device\n");
1114 iscsi_tgt_node_destruct(target, NULL, NULL);
1115 return NULL;
1116 }
1117
1118 TAILQ_INIT(&target->pg_map_head);
1119 rc = iscsi_target_node_add_pg_ig_maps(target, pg_tag_list,
1120 ig_tag_list, num_maps);
1121 if (rc != 0) {
1122 SPDK_ERRLOG("could not add map to target\n");
1123 iscsi_tgt_node_destruct(target, NULL, NULL);
1124 return NULL;
1125 }
1126
1127 target->disable_chap = disable_chap;
1128 target->require_chap = require_chap;
1129 target->mutual_chap = mutual_chap;
1130 target->chap_group = chap_group;
1131 target->header_digest = header_digest;
1132 target->data_digest = data_digest;
1133
1134 if (queue_depth > 0 && ((uint32_t)queue_depth <= g_iscsi.MaxQueueDepth)) {
1135 target->queue_depth = queue_depth;
1136 } else {
1137 SPDK_DEBUGLOG(iscsi, "QueueDepth %d is invalid and %d is used instead.\n",
1138 queue_depth, g_iscsi.MaxQueueDepth);
1139 target->queue_depth = g_iscsi.MaxQueueDepth;
1140 }
1141
1142 rc = iscsi_tgt_node_register(target);
1143 if (rc != 0) {
1144 SPDK_ERRLOG("register target is failed\n");
1145 iscsi_tgt_node_destruct(target, NULL, NULL);
1146 return NULL;
1147 }
1148
1149 return target;
1150 }
1151
1152 void
iscsi_shutdown_tgt_nodes(void)1153 iscsi_shutdown_tgt_nodes(void)
1154 {
1155 struct spdk_iscsi_tgt_node *target;
1156
1157 pthread_mutex_lock(&g_iscsi.mutex);
1158 while (!TAILQ_EMPTY(&g_iscsi.target_head)) {
1159 target = TAILQ_FIRST(&g_iscsi.target_head);
1160 TAILQ_REMOVE(&g_iscsi.target_head, target, tailq);
1161
1162 pthread_mutex_unlock(&g_iscsi.mutex);
1163
1164 iscsi_tgt_node_destruct(target, NULL, NULL);
1165
1166 pthread_mutex_lock(&g_iscsi.mutex);
1167 }
1168 pthread_mutex_unlock(&g_iscsi.mutex);
1169 }
1170
1171 void
iscsi_shutdown_tgt_node_by_name(const char * target_name,iscsi_tgt_node_destruct_cb cb_fn,void * cb_arg)1172 iscsi_shutdown_tgt_node_by_name(const char *target_name,
1173 iscsi_tgt_node_destruct_cb cb_fn, void *cb_arg)
1174 {
1175 struct spdk_iscsi_tgt_node *target;
1176
1177 pthread_mutex_lock(&g_iscsi.mutex);
1178 target = iscsi_find_tgt_node(target_name);
1179 if (target != NULL) {
1180 iscsi_tgt_node_unregister(target);
1181 pthread_mutex_unlock(&g_iscsi.mutex);
1182
1183 iscsi_tgt_node_destruct(target, cb_fn, cb_arg);
1184
1185 return;
1186 }
1187 pthread_mutex_unlock(&g_iscsi.mutex);
1188
1189 if (cb_fn) {
1190 cb_fn(cb_arg, -ENOENT);
1191 }
1192 }
1193
1194 bool
iscsi_tgt_node_is_destructed(struct spdk_iscsi_tgt_node * target)1195 iscsi_tgt_node_is_destructed(struct spdk_iscsi_tgt_node *target)
1196 {
1197 return target->destructed;
1198 }
1199
1200 int
iscsi_tgt_node_cleanup_luns(struct spdk_iscsi_conn * conn,struct spdk_iscsi_tgt_node * target)1201 iscsi_tgt_node_cleanup_luns(struct spdk_iscsi_conn *conn,
1202 struct spdk_iscsi_tgt_node *target)
1203 {
1204 struct spdk_scsi_lun *lun;
1205 struct spdk_iscsi_task *task;
1206
1207 for (lun = spdk_scsi_dev_get_first_lun(target->dev); lun != NULL;
1208 lun = spdk_scsi_dev_get_next_lun(lun)) {
1209 /* we create a fake management task per LUN to cleanup */
1210 task = iscsi_task_get(conn, NULL, iscsi_task_mgmt_cpl);
1211 if (!task) {
1212 SPDK_ERRLOG("Unable to acquire task\n");
1213 return -1;
1214 }
1215
1216 task->scsi.target_port = conn->target_port;
1217 task->scsi.initiator_port = conn->initiator_port;
1218 task->scsi.lun = lun;
1219
1220 iscsi_op_abort_task_set(task, SPDK_SCSI_TASK_FUNC_TARGET_RESET);
1221 }
1222
1223 return 0;
1224 }
1225
1226 void
iscsi_tgt_node_delete_map(struct spdk_iscsi_portal_grp * portal_group,struct spdk_iscsi_init_grp * initiator_group)1227 iscsi_tgt_node_delete_map(struct spdk_iscsi_portal_grp *portal_group,
1228 struct spdk_iscsi_init_grp *initiator_group)
1229 {
1230 struct spdk_iscsi_tgt_node *target;
1231
1232 pthread_mutex_lock(&g_iscsi.mutex);
1233 TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
1234 if (portal_group) {
1235 iscsi_tgt_node_delete_pg_map(target, portal_group);
1236 }
1237 if (initiator_group) {
1238 iscsi_tgt_node_delete_ig_maps(target, initiator_group);
1239 }
1240 }
1241 pthread_mutex_unlock(&g_iscsi.mutex);
1242 }
1243
1244 int
iscsi_tgt_node_add_lun(struct spdk_iscsi_tgt_node * target,const char * bdev_name,int lun_id)1245 iscsi_tgt_node_add_lun(struct spdk_iscsi_tgt_node *target,
1246 const char *bdev_name, int lun_id)
1247 {
1248 struct spdk_scsi_dev *dev;
1249 int rc;
1250
1251 if (target->num_active_conns > 0) {
1252 SPDK_ERRLOG("Target has active connections (count=%d)\n",
1253 target->num_active_conns);
1254 return -1;
1255 }
1256
1257 if (lun_id < -1) {
1258 SPDK_ERRLOG("Specified LUN ID (%d) is negative\n", lun_id);
1259 return -1;
1260 }
1261
1262 dev = target->dev;
1263 if (dev == NULL) {
1264 SPDK_ERRLOG("SCSI device is not found\n");
1265 return -1;
1266 }
1267
1268 rc = spdk_scsi_dev_add_lun(dev, bdev_name, lun_id, NULL, NULL);
1269 if (rc != 0) {
1270 SPDK_ERRLOG("spdk_scsi_dev_add_lun failed\n");
1271 return -1;
1272 }
1273
1274 return 0;
1275 }
1276
1277 int
iscsi_tgt_node_set_chap_params(struct spdk_iscsi_tgt_node * target,bool disable_chap,bool require_chap,bool mutual_chap,int32_t chap_group)1278 iscsi_tgt_node_set_chap_params(struct spdk_iscsi_tgt_node *target,
1279 bool disable_chap, bool require_chap,
1280 bool mutual_chap, int32_t chap_group)
1281 {
1282 if (!iscsi_check_chap_params(disable_chap, require_chap,
1283 mutual_chap, chap_group)) {
1284 return -EINVAL;
1285 }
1286
1287 pthread_mutex_lock(&target->mutex);
1288 target->disable_chap = disable_chap;
1289 target->require_chap = require_chap;
1290 target->mutual_chap = mutual_chap;
1291 target->chap_group = chap_group;
1292 pthread_mutex_unlock(&target->mutex);
1293
1294 return 0;
1295 }
1296
1297 static void
iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node * target,struct spdk_json_write_ctx * w)1298 iscsi_tgt_node_info_json(struct spdk_iscsi_tgt_node *target,
1299 struct spdk_json_write_ctx *w)
1300 {
1301 struct spdk_iscsi_pg_map *pg_map;
1302 struct spdk_iscsi_ig_map *ig_map;
1303 struct spdk_scsi_lun *lun;
1304
1305 spdk_json_write_object_begin(w);
1306
1307 spdk_json_write_named_string(w, "name", target->name);
1308
1309 if (target->alias[0] != '\0') {
1310 spdk_json_write_named_string(w, "alias_name", target->alias);
1311 }
1312
1313 spdk_json_write_named_array_begin(w, "pg_ig_maps");
1314 TAILQ_FOREACH(pg_map, &target->pg_map_head, tailq) {
1315 TAILQ_FOREACH(ig_map, &pg_map->ig_map_head, tailq) {
1316 spdk_json_write_object_begin(w);
1317 spdk_json_write_named_int32(w, "pg_tag", pg_map->pg->tag);
1318 spdk_json_write_named_int32(w, "ig_tag", ig_map->ig->tag);
1319 spdk_json_write_object_end(w);
1320 }
1321 }
1322 spdk_json_write_array_end(w);
1323
1324 spdk_json_write_named_array_begin(w, "luns");
1325 for (lun = spdk_scsi_dev_get_first_lun(target->dev); lun != NULL;
1326 lun = spdk_scsi_dev_get_next_lun(lun)) {
1327 spdk_json_write_object_begin(w);
1328 spdk_json_write_named_string(w, "bdev_name", spdk_scsi_lun_get_bdev_name(lun));
1329 spdk_json_write_named_int32(w, "lun_id", spdk_scsi_lun_get_id(lun));
1330 spdk_json_write_object_end(w);
1331 }
1332 spdk_json_write_array_end(w);
1333
1334 spdk_json_write_named_int32(w, "queue_depth", target->queue_depth);
1335
1336 spdk_json_write_named_bool(w, "disable_chap", target->disable_chap);
1337 spdk_json_write_named_bool(w, "require_chap", target->require_chap);
1338 spdk_json_write_named_bool(w, "mutual_chap", target->mutual_chap);
1339 spdk_json_write_named_int32(w, "chap_group", target->chap_group);
1340
1341 spdk_json_write_named_bool(w, "header_digest", target->header_digest);
1342 spdk_json_write_named_bool(w, "data_digest", target->data_digest);
1343
1344 spdk_json_write_object_end(w);
1345 }
1346
1347 static void
iscsi_tgt_node_histogram_config_json(struct spdk_iscsi_tgt_node * target,struct spdk_json_write_ctx * w)1348 iscsi_tgt_node_histogram_config_json(struct spdk_iscsi_tgt_node *target,
1349 struct spdk_json_write_ctx *w)
1350 {
1351 if (!target->histogram) {
1352 return;
1353 }
1354
1355 spdk_json_write_object_begin(w);
1356 spdk_json_write_named_string(w, "method", "iscsi_enable_histogram");
1357
1358 spdk_json_write_named_object_begin(w, "params");
1359 spdk_json_write_named_string(w, "name", target->name);
1360
1361 spdk_json_write_named_bool(w, "enable", true);
1362 spdk_json_write_object_end(w);
1363
1364 spdk_json_write_object_end(w);
1365 }
1366
1367 static void
iscsi_tgt_node_config_json(struct spdk_iscsi_tgt_node * target,struct spdk_json_write_ctx * w)1368 iscsi_tgt_node_config_json(struct spdk_iscsi_tgt_node *target,
1369 struct spdk_json_write_ctx *w)
1370 {
1371 spdk_json_write_object_begin(w);
1372
1373 spdk_json_write_named_string(w, "method", "iscsi_create_target_node");
1374
1375 spdk_json_write_name(w, "params");
1376 iscsi_tgt_node_info_json(target, w);
1377
1378 spdk_json_write_object_end(w);
1379
1380 iscsi_tgt_node_histogram_config_json(target, w);
1381 }
1382
1383 void
iscsi_tgt_nodes_info_json(struct spdk_json_write_ctx * w)1384 iscsi_tgt_nodes_info_json(struct spdk_json_write_ctx *w)
1385 {
1386 struct spdk_iscsi_tgt_node *target;
1387
1388 TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
1389 iscsi_tgt_node_info_json(target, w);
1390 }
1391 }
1392
1393 void
iscsi_tgt_nodes_config_json(struct spdk_json_write_ctx * w)1394 iscsi_tgt_nodes_config_json(struct spdk_json_write_ctx *w)
1395 {
1396 struct spdk_iscsi_tgt_node *target;
1397
1398 TAILQ_FOREACH(target, &g_iscsi.target_head, tailq) {
1399 iscsi_tgt_node_config_json(target, w);
1400 }
1401 }
1402
1403 int
iscsi_tgt_node_enable_histogram(struct spdk_iscsi_tgt_node * target,bool enable)1404 iscsi_tgt_node_enable_histogram(struct spdk_iscsi_tgt_node *target, bool enable)
1405 {
1406 if (enable) {
1407 if (!target->histogram) {
1408 target->histogram = spdk_histogram_data_alloc();
1409 if (target->histogram == NULL) {
1410 SPDK_ERRLOG("could not allocate histogram\n");
1411 return -ENOMEM;
1412 }
1413 }
1414 } else {
1415 if (target->histogram) {
1416 spdk_histogram_data_free(target->histogram);
1417 target->histogram = NULL;
1418 }
1419 }
1420
1421 return 0;
1422 }
1423