1 /*
2 Copyright (C) 2010 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU Lesser General Public License as published by
6 the Free Software Foundation; either version 2.1 of the License, or
7 (at your option) any later version.
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 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public License
15 along with this program; if not, see <http://www.gnu.org/licenses/>.
16 */
17 #ifdef HAVE_CONFIG_H
18 #include "config.h"
19 #endif
20
21 #ifdef HAVE_POLL_H
22 #include <poll.h>
23 #endif
24
25 #ifdef AROS
26 #include "aros/aros_compat.h"
27 #endif
28
29 #if defined(_WIN32)
30 #include <winsock2.h>
31 #include "win32/win32_compat.h"
32 #endif
33
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif
37
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <time.h>
42 #include "iscsi.h"
43 #include "iscsi-private.h"
44 #include "scsi-lowlevel.h"
45
46 struct iscsi_sync_state {
47 int finished;
48 int status;
49 void *ptr;
50 struct scsi_task *task;
51 };
52
53 static void
event_loop(struct iscsi_context * iscsi,struct iscsi_sync_state * state)54 event_loop(struct iscsi_context *iscsi, struct iscsi_sync_state *state)
55 {
56 struct pollfd pfd;
57 int ret;
58
59 while (state->finished == 0) {
60 short revents;
61
62 pfd.fd = iscsi_get_fd(iscsi);
63 pfd.events = iscsi_which_events(iscsi);
64
65 if ((ret = poll(&pfd, 1, 1000)) < 0) {
66 iscsi_set_error(iscsi, "Poll failed");
67 state->status = -1;
68 return;
69 }
70 revents = (ret == 0) ? 0 : pfd.revents;
71 if (iscsi_service(iscsi, revents) < 0) {
72 iscsi_set_error(iscsi,
73 "iscsi_service failed with : %s",
74 iscsi_get_error(iscsi));
75 state->status = -1;
76 return;
77 }
78 }
79 }
80
81 /*
82 * Synchronous iSCSI commands
83 */
84 static void
iscsi_sync_cb(struct iscsi_context * iscsi _U_,int status,void * command_data _U_,void * private_data)85 iscsi_sync_cb(struct iscsi_context *iscsi _U_, int status,
86 void *command_data _U_, void *private_data)
87 {
88 struct iscsi_sync_state *state = private_data;
89
90 state->status = status;
91 state->finished = 1;
92 }
93
94 int
iscsi_connect_sync(struct iscsi_context * iscsi,const char * portal)95 iscsi_connect_sync(struct iscsi_context *iscsi, const char *portal)
96 {
97 struct iscsi_sync_state state;
98
99 memset(&state, 0, sizeof(state));
100
101 if (iscsi_connect_async(iscsi, portal,
102 iscsi_sync_cb, &state) != 0) {
103 iscsi_set_error(iscsi,
104 "Failed to start connect() %s",
105 iscsi_get_error(iscsi));
106 return -1;
107 }
108
109 event_loop(iscsi, &state);
110
111 /* clear connect_data so it doesnt point to our stack */
112 iscsi->connect_data = NULL;
113
114 /* in case of error, cancel any pending pdus */
115 if (state.status != SCSI_STATUS_GOOD) {
116 iscsi_cancel_pdus(iscsi);
117 }
118
119 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
120 }
121
122 int
iscsi_full_connect_sync(struct iscsi_context * iscsi,const char * portal,int lun)123 iscsi_full_connect_sync(struct iscsi_context *iscsi,
124 const char *portal, int lun)
125 {
126 struct iscsi_sync_state state;
127
128 memset(&state, 0, sizeof(state));
129
130 if (iscsi_full_connect_async(iscsi, portal, lun,
131 iscsi_sync_cb, &state) != 0) {
132 iscsi_set_error(iscsi,
133 "Failed to start full connect %s",
134 iscsi_get_error(iscsi));
135 return -1;
136 }
137
138 event_loop(iscsi, &state);
139
140 /* in case of error, cancel any pending pdus */
141 if (state.status != SCSI_STATUS_GOOD) {
142 iscsi_cancel_pdus(iscsi);
143 }
144
145 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
146 }
147
iscsi_login_sync(struct iscsi_context * iscsi)148 int iscsi_login_sync(struct iscsi_context *iscsi)
149 {
150 struct iscsi_sync_state state;
151
152 memset(&state, 0, sizeof(state));
153
154 if (iscsi_login_async(iscsi, iscsi_sync_cb, &state) != 0) {
155 iscsi_set_error(iscsi, "Failed to login. %s",
156 iscsi_get_error(iscsi));
157 return -1;
158 }
159
160 event_loop(iscsi, &state);
161
162 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
163 }
164
iscsi_logout_sync(struct iscsi_context * iscsi)165 int iscsi_logout_sync(struct iscsi_context *iscsi)
166 {
167 struct iscsi_sync_state state;
168
169 memset(&state, 0, sizeof(state));
170
171 if (iscsi_logout_async(iscsi, iscsi_sync_cb, &state) != 0) {
172 iscsi_set_error(iscsi, "Failed to start logout() %s",
173 iscsi_get_error(iscsi));
174 return -1;
175 }
176
177 event_loop(iscsi, &state);
178
179 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
180 }
181
182 static void
reconnect_event_loop(struct iscsi_context * iscsi,struct iscsi_sync_state * state)183 reconnect_event_loop(struct iscsi_context *iscsi, struct iscsi_sync_state *state)
184 {
185 struct pollfd pfd;
186 int ret;
187 while (iscsi->old_iscsi) {
188 pfd.fd = iscsi_get_fd(iscsi);
189 pfd.events = iscsi_which_events(iscsi);
190
191 if (!pfd.events) {
192 sleep(1);
193 continue;
194 }
195
196 if ((ret = poll(&pfd, 1, 1000)) < 0) {
197 iscsi_set_error(iscsi, "Poll failed");
198 state->status = -1;
199 return;
200 }
201
202 if (iscsi_service(iscsi, pfd.revents) < 0) {
203 iscsi_set_error(iscsi,
204 "iscsi_service failed with : %s",
205 iscsi_get_error(iscsi));
206 state->status = -1;
207 return;
208 }
209 }
210 state->status = 0;
211 }
212
iscsi_reconnect_sync(struct iscsi_context * iscsi)213 int iscsi_reconnect_sync(struct iscsi_context *iscsi)
214 {
215 struct iscsi_sync_state state;
216
217 memset(&state, 0, sizeof(state));
218
219 if (iscsi_reconnect(iscsi) != 0) {
220 iscsi_set_error(iscsi, "Failed to reconnect. %s", iscsi_get_error(iscsi));
221 return -1;
222 }
223
224 reconnect_event_loop(iscsi, &state);
225
226 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
227 }
228
229 static void
iscsi_task_mgmt_sync_cb(struct iscsi_context * iscsi,int status,void * command_data,void * private_data)230 iscsi_task_mgmt_sync_cb(struct iscsi_context *iscsi, int status,
231 void *command_data, void *private_data)
232 {
233 struct iscsi_sync_state *state = private_data;
234
235 state->status = status;
236 state->finished = 1;
237
238 /* The task mgmt command might have completed successfully
239 * but the target might have responded with
240 * "command not implemented" or something.
241 */
242 if (command_data && *(uint32_t *)command_data) {
243 switch (*(uint32_t *)command_data) {
244 case 1: iscsi_set_error(iscsi, "TASK MGMT responded Task Does Not Exist");
245 break;
246 case 2: iscsi_set_error(iscsi, "TASK MGMT responded LUN Does Not Exist");
247 break;
248 case 3: iscsi_set_error(iscsi, "TASK MGMT responded Task Still Allegiant");
249 break;
250 case 4: iscsi_set_error(iscsi, "TASK MGMT responded Task Allegiance Reassignment Not Supported");
251 break;
252 case 5: iscsi_set_error(iscsi, "TASK MGMT responded Task Mgmt Function Not Supported");
253 break;
254 case 6: iscsi_set_error(iscsi, "TASK MGMT responded Function Authorization Failed");
255 break;
256 case 255: iscsi_set_error(iscsi, "TASK MGMT responded Function Rejected");
257 break;
258 }
259
260 state->status = SCSI_STATUS_ERROR;
261 }
262 }
263
264 int
iscsi_task_mgmt_sync(struct iscsi_context * iscsi,int lun,enum iscsi_task_mgmt_funcs function,uint32_t ritt,uint32_t rcmdsn)265 iscsi_task_mgmt_sync(struct iscsi_context *iscsi,
266 int lun, enum iscsi_task_mgmt_funcs function,
267 uint32_t ritt, uint32_t rcmdsn)
268 {
269 struct iscsi_sync_state state;
270
271 memset(&state, 0, sizeof(state));
272
273 if (iscsi_task_mgmt_async(iscsi, lun, function,
274 ritt, rcmdsn,
275 iscsi_task_mgmt_sync_cb, &state) != 0) {
276 iscsi_set_error(iscsi, "Failed to send TASK MGMT function: %s",
277 iscsi_get_error(iscsi));
278 return -1;
279 }
280
281 event_loop(iscsi, &state);
282
283 return (state.status == SCSI_STATUS_GOOD) ? 0 : -1;
284 }
285
286 int
iscsi_task_mgmt_abort_task_sync(struct iscsi_context * iscsi,struct scsi_task * task)287 iscsi_task_mgmt_abort_task_sync(struct iscsi_context *iscsi,
288 struct scsi_task *task)
289 {
290 return iscsi_task_mgmt_sync(iscsi, task->lun,
291 ISCSI_TM_ABORT_TASK,
292 task->itt, task->cmdsn);
293 }
294
295 int
iscsi_task_mgmt_abort_task_set_sync(struct iscsi_context * iscsi,uint32_t lun)296 iscsi_task_mgmt_abort_task_set_sync(struct iscsi_context *iscsi,
297 uint32_t lun)
298 {
299 iscsi_scsi_cancel_all_tasks(iscsi);
300
301 return iscsi_task_mgmt_sync(iscsi, lun,
302 ISCSI_TM_ABORT_TASK_SET,
303 0xffffffff, 0);
304 }
305
306 int
iscsi_task_mgmt_lun_reset_sync(struct iscsi_context * iscsi,uint32_t lun)307 iscsi_task_mgmt_lun_reset_sync(struct iscsi_context *iscsi,
308 uint32_t lun)
309 {
310 iscsi_scsi_cancel_all_tasks(iscsi);
311
312 return iscsi_task_mgmt_sync(iscsi, lun,
313 ISCSI_TM_LUN_RESET,
314 0xffffffff, 0);
315 }
316
317 int
iscsi_task_mgmt_target_warm_reset_sync(struct iscsi_context * iscsi)318 iscsi_task_mgmt_target_warm_reset_sync(struct iscsi_context *iscsi)
319 {
320 iscsi_scsi_cancel_all_tasks(iscsi);
321
322 return iscsi_task_mgmt_sync(iscsi, 0,
323 ISCSI_TM_TARGET_WARM_RESET,
324 0xffffffff, 0);
325 }
326
327
328 int
iscsi_task_mgmt_target_cold_reset_sync(struct iscsi_context * iscsi)329 iscsi_task_mgmt_target_cold_reset_sync(struct iscsi_context *iscsi)
330 {
331 iscsi_scsi_cancel_all_tasks(iscsi);
332
333 return iscsi_task_mgmt_sync(iscsi, 0,
334 ISCSI_TM_TARGET_COLD_RESET,
335 0xffffffff, 0);
336 }
337
338
339 /*
340 * Synchronous SCSI commands
341 */
342 static void
scsi_sync_cb(struct iscsi_context * iscsi _U_,int status,void * command_data,void * private_data)343 scsi_sync_cb(struct iscsi_context *iscsi _U_, int status, void *command_data,
344 void *private_data)
345 {
346 struct scsi_task *task = command_data;
347 struct iscsi_sync_state *state = private_data;
348
349 task->status = status;
350
351 state->status = status;
352 state->finished = 1;
353 state->task = task;
354 }
355
356 struct scsi_task *
iscsi_reportluns_sync(struct iscsi_context * iscsi,int report_type,int alloc_len)357 iscsi_reportluns_sync(struct iscsi_context *iscsi, int report_type,
358 int alloc_len)
359 {
360 struct iscsi_sync_state state;
361
362 memset(&state, 0, sizeof(state));
363
364 if (iscsi_reportluns_task(iscsi, report_type, alloc_len,
365 scsi_sync_cb, &state) == NULL) {
366 iscsi_set_error(iscsi, "Failed to send ReportLuns command");
367 return NULL;
368 }
369
370 event_loop(iscsi, &state);
371
372 return state.task;
373 }
374
375
376 struct scsi_task *
iscsi_testunitready_sync(struct iscsi_context * iscsi,int lun)377 iscsi_testunitready_sync(struct iscsi_context *iscsi, int lun)
378 {
379 struct iscsi_sync_state state;
380
381 memset(&state, 0, sizeof(state));
382
383 if (iscsi_testunitready_task(iscsi, lun,
384 scsi_sync_cb, &state) == NULL) {
385 iscsi_set_error(iscsi,
386 "Failed to send TestUnitReady command");
387 return NULL;
388 }
389
390 event_loop(iscsi, &state);
391
392 return state.task;
393 }
394
395 struct scsi_task *
iscsi_inquiry_sync(struct iscsi_context * iscsi,int lun,int evpd,int page_code,int maxsize)396 iscsi_inquiry_sync(struct iscsi_context *iscsi, int lun, int evpd,
397 int page_code, int maxsize)
398 {
399 struct iscsi_sync_state state;
400
401 memset(&state, 0, sizeof(state));
402
403 if (iscsi_inquiry_task(iscsi, lun, evpd, page_code, maxsize,
404 scsi_sync_cb, &state) == NULL) {
405 iscsi_set_error(iscsi, "Failed to send Inquiry command");
406 return NULL;
407 }
408
409 event_loop(iscsi, &state);
410
411 return state.task;
412 }
413
414 struct scsi_task *
iscsi_read6_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize)415 iscsi_read6_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
416 uint32_t datalen, int blocksize)
417 {
418 struct iscsi_sync_state state;
419
420 memset(&state, 0, sizeof(state));
421
422 if (iscsi_read6_task(iscsi, lun, lba, datalen, blocksize,
423 scsi_sync_cb, &state) == NULL) {
424 iscsi_set_error(iscsi,
425 "Failed to send Read6 command");
426 return NULL;
427 }
428
429 event_loop(iscsi, &state);
430
431 return state.task;
432 }
433
434 struct scsi_task *
iscsi_read6_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize,struct scsi_iovec * iov,int niov)435 iscsi_read6_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
436 uint32_t datalen, int blocksize, struct scsi_iovec *iov, int niov)
437 {
438 struct iscsi_sync_state state;
439
440 memset(&state, 0, sizeof(state));
441
442 if (iscsi_read6_iov_task(iscsi, lun, lba, datalen, blocksize,
443 scsi_sync_cb, &state, iov, niov) == NULL) {
444 iscsi_set_error(iscsi,
445 "Failed to send Read6 command");
446 return NULL;
447 }
448
449 event_loop(iscsi, &state);
450
451 return state.task;
452 }
453
454 struct scsi_task *
iscsi_read10_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number)455 iscsi_read10_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
456 uint32_t datalen, int blocksize,
457 int rdprotect, int dpo, int fua, int fua_nv, int group_number)
458 {
459 struct iscsi_sync_state state;
460
461 memset(&state, 0, sizeof(state));
462
463 if (iscsi_read10_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
464 dpo, fua, fua_nv, group_number,
465 scsi_sync_cb, &state) == NULL) {
466 iscsi_set_error(iscsi,
467 "Failed to send Read10 command");
468 return NULL;
469 }
470
471 event_loop(iscsi, &state);
472
473 return state.task;
474 }
475
476 struct scsi_task *
iscsi_read10_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)477 iscsi_read10_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
478 uint32_t datalen, int blocksize,
479 int rdprotect, int dpo, int fua, int fua_nv, int group_number,
480 struct scsi_iovec *iov, int niov)
481 {
482 struct iscsi_sync_state state;
483
484 memset(&state, 0, sizeof(state));
485
486 if (iscsi_read10_iov_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
487 dpo, fua, fua_nv, group_number,
488 scsi_sync_cb, &state, iov, niov) == NULL) {
489 iscsi_set_error(iscsi,
490 "Failed to send Read10 command");
491 return NULL;
492 }
493
494 event_loop(iscsi, &state);
495
496 return state.task;
497 }
498
499 struct scsi_task *
iscsi_read12_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number)500 iscsi_read12_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
501 uint32_t datalen, int blocksize,
502 int rdprotect, int dpo, int fua, int fua_nv, int group_number)
503 {
504 struct iscsi_sync_state state;
505
506 memset(&state, 0, sizeof(state));
507
508 if (iscsi_read12_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
509 dpo, fua, fua_nv, group_number,
510 scsi_sync_cb, &state) == NULL) {
511 iscsi_set_error(iscsi,
512 "Failed to send Read12 command");
513 return NULL;
514 }
515
516 event_loop(iscsi, &state);
517
518 return state.task;
519 }
520
521 struct scsi_task *
iscsi_read12_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)522 iscsi_read12_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
523 uint32_t datalen, int blocksize,
524 int rdprotect, int dpo, int fua, int fua_nv, int group_number,
525 struct scsi_iovec *iov, int niov)
526 {
527 struct iscsi_sync_state state;
528
529 memset(&state, 0, sizeof(state));
530
531 if (iscsi_read12_iov_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
532 dpo, fua, fua_nv, group_number,
533 scsi_sync_cb, &state, iov, niov) == NULL) {
534 iscsi_set_error(iscsi,
535 "Failed to send Read12 command");
536 return NULL;
537 }
538
539 event_loop(iscsi, &state);
540
541 return state.task;
542 }
543
544 struct scsi_task *
iscsi_read16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number)545 iscsi_read16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
546 uint32_t datalen, int blocksize,
547 int rdprotect, int dpo, int fua, int fua_nv, int group_number)
548 {
549 struct iscsi_sync_state state;
550
551 memset(&state, 0, sizeof(state));
552
553 if (iscsi_read16_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
554 dpo, fua, fua_nv, group_number,
555 scsi_sync_cb, &state) == NULL) {
556 iscsi_set_error(iscsi,
557 "Failed to send Read16 command");
558 return NULL;
559 }
560
561 event_loop(iscsi, &state);
562
563 return state.task;
564 }
565
566 struct scsi_task *
iscsi_read16_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,uint32_t datalen,int blocksize,int rdprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)567 iscsi_read16_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
568 uint32_t datalen, int blocksize,
569 int rdprotect, int dpo, int fua, int fua_nv, int group_number,
570 struct scsi_iovec *iov, int niov)
571 {
572 struct iscsi_sync_state state;
573
574 memset(&state, 0, sizeof(state));
575
576 if (iscsi_read16_iov_task(iscsi, lun, lba, datalen, blocksize, rdprotect,
577 dpo, fua, fua_nv, group_number,
578 scsi_sync_cb, &state, iov, niov) == NULL) {
579 iscsi_set_error(iscsi,
580 "Failed to send Read16 command");
581 return NULL;
582 }
583
584 event_loop(iscsi, &state);
585
586 return state.task;
587 }
588
589 struct scsi_task *
iscsi_readcapacity10_sync(struct iscsi_context * iscsi,int lun,int lba,int pmi)590 iscsi_readcapacity10_sync(struct iscsi_context *iscsi, int lun, int lba,
591 int pmi)
592 {
593 struct iscsi_sync_state state;
594
595 memset(&state, 0, sizeof(state));
596
597 if (iscsi_readcapacity10_task(iscsi, lun, lba, pmi,
598 scsi_sync_cb, &state) == NULL) {
599 iscsi_set_error(iscsi,
600 "Failed to send ReadCapacity10 command");
601 return NULL;
602 }
603
604 event_loop(iscsi, &state);
605
606 return state.task;
607 }
608
609 struct scsi_task *
iscsi_readcapacity16_sync(struct iscsi_context * iscsi,int lun)610 iscsi_readcapacity16_sync(struct iscsi_context *iscsi, int lun)
611 {
612 struct iscsi_sync_state state;
613
614 memset(&state, 0, sizeof(state));
615
616 if (iscsi_readcapacity16_task(iscsi, lun,
617 scsi_sync_cb, &state) == NULL) {
618 iscsi_set_error(iscsi,
619 "Failed to send ReadCapacity16 command");
620 return NULL;
621 }
622
623 event_loop(iscsi, &state);
624
625 return state.task;
626 }
627
628 struct scsi_task *
iscsi_readdefectdata10_sync(struct iscsi_context * iscsi,int lun,int req_plist,int req_glist,int defect_list_format,uint16_t alloc_len)629 iscsi_readdefectdata10_sync(struct iscsi_context *iscsi, int lun,
630 int req_plist, int req_glist,
631 int defect_list_format, uint16_t alloc_len)
632 {
633 struct iscsi_sync_state state;
634
635 memset(&state, 0, sizeof(state));
636
637 if (iscsi_readdefectdata10_task(iscsi, lun,
638 req_plist, req_glist,
639 defect_list_format, alloc_len,
640 scsi_sync_cb, &state) == NULL) {
641 iscsi_set_error(iscsi,
642 "Failed to send ReadDefectData10 command");
643 return NULL;
644 }
645
646 event_loop(iscsi, &state);
647
648 return state.task;
649 }
650
651 struct scsi_task *
iscsi_readdefectdata12_sync(struct iscsi_context * iscsi,int lun,int req_plist,int req_glist,int defect_list_format,uint32_t address_descriptor_index,uint32_t alloc_len)652 iscsi_readdefectdata12_sync(struct iscsi_context *iscsi, int lun,
653 int req_plist, int req_glist,
654 int defect_list_format,
655 uint32_t address_descriptor_index,
656 uint32_t alloc_len)
657 {
658 struct iscsi_sync_state state;
659
660 memset(&state, 0, sizeof(state));
661
662 if (iscsi_readdefectdata12_task(iscsi, lun,
663 req_plist, req_glist,
664 defect_list_format,
665 address_descriptor_index, alloc_len,
666 scsi_sync_cb, &state) == NULL) {
667 iscsi_set_error(iscsi,
668 "Failed to send ReadDefectData12 command");
669 return NULL;
670 }
671
672 event_loop(iscsi, &state);
673
674 return state.task;
675 }
676
677 struct scsi_task *
iscsi_sanitize_sync(struct iscsi_context * iscsi,int lun,int immed,int ause,int sa,int param_len,struct iscsi_data * data)678 iscsi_sanitize_sync(struct iscsi_context *iscsi, int lun,
679 int immed, int ause, int sa, int param_len,
680 struct iscsi_data *data)
681 {
682 struct iscsi_sync_state state;
683
684 memset(&state, 0, sizeof(state));
685
686 if (iscsi_sanitize_task(iscsi, lun,
687 immed, ause, sa, param_len, data,
688 scsi_sync_cb, &state) == NULL) {
689 iscsi_set_error(iscsi,
690 "Failed to send Sanitize command");
691 return NULL;
692 }
693
694 event_loop(iscsi, &state);
695
696 return state.task;
697 }
698
699 struct scsi_task *
iscsi_sanitize_block_erase_sync(struct iscsi_context * iscsi,int lun,int immed,int ause)700 iscsi_sanitize_block_erase_sync(struct iscsi_context *iscsi, int lun,
701 int immed, int ause)
702 {
703 struct iscsi_sync_state state;
704
705 memset(&state, 0, sizeof(state));
706
707 if (iscsi_sanitize_block_erase_task(iscsi, lun,
708 immed, ause,
709 scsi_sync_cb, &state) == NULL) {
710 iscsi_set_error(iscsi,
711 "Failed to send Sanitize command");
712 return NULL;
713 }
714
715 event_loop(iscsi, &state);
716
717 return state.task;
718 }
719
720 struct scsi_task *
iscsi_sanitize_crypto_erase_sync(struct iscsi_context * iscsi,int lun,int immed,int ause)721 iscsi_sanitize_crypto_erase_sync(struct iscsi_context *iscsi, int lun,
722 int immed, int ause)
723 {
724 struct iscsi_sync_state state;
725
726 memset(&state, 0, sizeof(state));
727
728 if (iscsi_sanitize_crypto_erase_task(iscsi, lun,
729 immed, ause,
730 scsi_sync_cb, &state) == NULL) {
731 iscsi_set_error(iscsi,
732 "Failed to send Sanitize command");
733 return NULL;
734 }
735
736 event_loop(iscsi, &state);
737
738 return state.task;
739 }
740
741 struct scsi_task *
iscsi_sanitize_exit_failure_mode_sync(struct iscsi_context * iscsi,int lun,int immed,int ause)742 iscsi_sanitize_exit_failure_mode_sync(struct iscsi_context *iscsi, int lun,
743 int immed, int ause)
744 {
745 struct iscsi_sync_state state;
746
747 memset(&state, 0, sizeof(state));
748
749 if (iscsi_sanitize_exit_failure_mode_task(iscsi, lun,
750 immed, ause,
751 scsi_sync_cb, &state) == NULL) {
752 iscsi_set_error(iscsi,
753 "Failed to send Sanitize command");
754 return NULL;
755 }
756
757 event_loop(iscsi, &state);
758
759 return state.task;
760 }
761
762 struct scsi_task *
iscsi_get_lba_status_sync(struct iscsi_context * iscsi,int lun,uint64_t starting_lba,uint32_t alloc_len)763 iscsi_get_lba_status_sync(struct iscsi_context *iscsi, int lun, uint64_t starting_lba, uint32_t alloc_len)
764 {
765 struct iscsi_sync_state state;
766
767 memset(&state, 0, sizeof(state));
768
769 if (iscsi_get_lba_status_task(iscsi, lun, starting_lba, alloc_len,
770 scsi_sync_cb, &state) == NULL) {
771 iscsi_set_error(iscsi,
772 "Failed to send GetLbaStatus command");
773 return NULL;
774 }
775
776 event_loop(iscsi, &state);
777
778 return state.task;
779 }
780
781 struct scsi_task *
iscsi_synchronizecache10_sync(struct iscsi_context * iscsi,int lun,int lba,int num_blocks,int syncnv,int immed)782 iscsi_synchronizecache10_sync(struct iscsi_context *iscsi, int lun, int lba,
783 int num_blocks, int syncnv, int immed)
784 {
785 struct iscsi_sync_state state;
786
787 memset(&state, 0, sizeof(state));
788
789 if (iscsi_synchronizecache10_task(iscsi, lun, lba, num_blocks,
790 syncnv, immed,
791 scsi_sync_cb, &state) == NULL) {
792 iscsi_set_error(iscsi,
793 "Failed to send SynchronizeCache10 command");
794 return NULL;
795 }
796
797 event_loop(iscsi, &state);
798
799 return state.task;
800 }
801
802 struct scsi_task *
iscsi_startstopunit_sync(struct iscsi_context * iscsi,int lun,int immed,int pcm,int pc,int no_flush,int loej,int start)803 iscsi_startstopunit_sync(struct iscsi_context *iscsi, int lun,
804 int immed, int pcm, int pc,
805 int no_flush, int loej, int start)
806 {
807 struct iscsi_sync_state state;
808
809 memset(&state, 0, sizeof(state));
810
811 if (iscsi_startstopunit_task(iscsi, lun, immed, pcm, pc,
812 no_flush, loej, start,
813 scsi_sync_cb, &state) == NULL) {
814 iscsi_set_error(iscsi,
815 "Failed to send StartStopUnit command");
816 return NULL;
817 }
818
819 event_loop(iscsi, &state);
820
821 return state.task;
822 }
823
824 struct scsi_task *
iscsi_preventallow_sync(struct iscsi_context * iscsi,int lun,int prevent)825 iscsi_preventallow_sync(struct iscsi_context *iscsi, int lun,
826 int prevent)
827 {
828 struct iscsi_sync_state state;
829
830 memset(&state, 0, sizeof(state));
831
832 if (iscsi_preventallow_task(iscsi, lun, prevent,
833 scsi_sync_cb, &state) == NULL) {
834 iscsi_set_error(iscsi,
835 "Failed to send PreventAllowMediumRemoval command");
836 return NULL;
837 }
838
839 event_loop(iscsi, &state);
840
841 return state.task;
842 }
843
844 struct scsi_task *
iscsi_synchronizecache16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,uint32_t num_blocks,int syncnv,int immed)845 iscsi_synchronizecache16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
846 uint32_t num_blocks, int syncnv, int immed)
847 {
848 struct iscsi_sync_state state;
849
850 memset(&state, 0, sizeof(state));
851
852 if (iscsi_synchronizecache16_task(iscsi, lun, lba, num_blocks,
853 syncnv, immed,
854 scsi_sync_cb, &state) == NULL) {
855 iscsi_set_error(iscsi,
856 "Failed to send SynchronizeCache16 command");
857 return NULL;
858 }
859
860 event_loop(iscsi, &state);
861
862 return state.task;
863 }
864
865 struct scsi_task *
iscsi_prefetch10_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,int num_blocks,int immed,int group)866 iscsi_prefetch10_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
867 int num_blocks, int immed, int group)
868 {
869 struct iscsi_sync_state state;
870
871 memset(&state, 0, sizeof(state));
872
873 if (iscsi_prefetch10_task(iscsi, lun, lba, num_blocks,
874 immed, group,
875 scsi_sync_cb, &state) == NULL) {
876 iscsi_set_error(iscsi,
877 "Failed to send PreFetch10 command");
878 return NULL;
879 }
880
881 event_loop(iscsi, &state);
882
883 return state.task;
884 }
885
886 struct scsi_task *
iscsi_prefetch16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,int num_blocks,int immed,int group)887 iscsi_prefetch16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
888 int num_blocks, int immed, int group)
889 {
890 struct iscsi_sync_state state;
891
892 memset(&state, 0, sizeof(state));
893
894 if (iscsi_prefetch16_task(iscsi, lun, lba, num_blocks,
895 immed, group,
896 scsi_sync_cb, &state) == NULL) {
897 iscsi_set_error(iscsi,
898 "Failed to send PreFetch16 command");
899 return NULL;
900 }
901
902 event_loop(iscsi, &state);
903
904 return state.task;
905 }
906
907 struct scsi_task *
iscsi_write10_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number)908 iscsi_write10_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
909 unsigned char *data, uint32_t datalen, int blocksize,
910 int wrprotect, int dpo, int fua, int fua_nv, int group_number)
911 {
912 struct iscsi_sync_state state;
913
914 memset(&state, 0, sizeof(state));
915
916 if (iscsi_write10_task(iscsi, lun, lba, data, datalen, blocksize,
917 wrprotect, dpo, fua, fua_nv, group_number,
918 scsi_sync_cb, &state) == NULL) {
919 iscsi_set_error(iscsi,
920 "Failed to send Write10 command");
921 return NULL;
922 }
923
924 event_loop(iscsi, &state);
925
926 return state.task;
927 }
928
929 struct scsi_task *
iscsi_write10_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)930 iscsi_write10_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
931 unsigned char *data, uint32_t datalen, int blocksize,
932 int wrprotect, int dpo, int fua, int fua_nv, int group_number,
933 struct scsi_iovec *iov, int niov)
934 {
935 struct iscsi_sync_state state;
936
937 memset(&state, 0, sizeof(state));
938
939 if (iscsi_write10_iov_task(iscsi, lun, lba, data, datalen, blocksize,
940 wrprotect, dpo, fua, fua_nv, group_number,
941 scsi_sync_cb, &state, iov, niov) == NULL) {
942 iscsi_set_error(iscsi,
943 "Failed to send Write10 command");
944 return NULL;
945 }
946
947 event_loop(iscsi, &state);
948
949 return state.task;
950 }
951
952 struct scsi_task *
iscsi_write12_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number)953 iscsi_write12_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
954 unsigned char *data, uint32_t datalen, int blocksize,
955 int wrprotect, int dpo, int fua, int fua_nv, int group_number)
956 {
957 struct iscsi_sync_state state;
958
959 memset(&state, 0, sizeof(state));
960
961 if (iscsi_write12_task(iscsi, lun, lba,
962 data, datalen, blocksize, wrprotect,
963 dpo, fua, fua_nv, group_number,
964 scsi_sync_cb, &state) == NULL) {
965 iscsi_set_error(iscsi,
966 "Failed to send Write12 command");
967 return NULL;
968 }
969
970 event_loop(iscsi, &state);
971
972 return state.task;
973 }
974
975 struct scsi_task *
iscsi_write12_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)976 iscsi_write12_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
977 unsigned char *data, uint32_t datalen, int blocksize,
978 int wrprotect, int dpo, int fua, int fua_nv, int group_number,
979 struct scsi_iovec *iov,int niov)
980 {
981 struct iscsi_sync_state state;
982
983 memset(&state, 0, sizeof(state));
984
985 if (iscsi_write12_iov_task(iscsi, lun, lba,
986 data, datalen, blocksize, wrprotect,
987 dpo, fua, fua_nv, group_number,
988 scsi_sync_cb, &state, iov, niov) == NULL) {
989 iscsi_set_error(iscsi,
990 "Failed to send Write12 command");
991 return NULL;
992 }
993
994 event_loop(iscsi, &state);
995
996 return state.task;
997 }
998
999 struct scsi_task *
iscsi_write16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number)1000 iscsi_write16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1001 unsigned char *data, uint32_t datalen, int blocksize,
1002 int wrprotect, int dpo, int fua, int fua_nv, int group_number)
1003 {
1004 struct iscsi_sync_state state;
1005
1006 memset(&state, 0, sizeof(state));
1007
1008 if (iscsi_write16_task(iscsi, lun, lba,
1009 data, datalen, blocksize, wrprotect,
1010 dpo, fua, fua_nv, group_number,
1011 scsi_sync_cb, &state) == NULL) {
1012 iscsi_set_error(iscsi,
1013 "Failed to send Write16 command");
1014 return NULL;
1015 }
1016
1017 event_loop(iscsi, &state);
1018
1019 return state.task;
1020 }
1021
1022 struct scsi_task *
iscsi_write16_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)1023 iscsi_write16_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1024 unsigned char *data, uint32_t datalen, int blocksize,
1025 int wrprotect, int dpo, int fua, int fua_nv, int group_number,
1026 struct scsi_iovec *iov, int niov)
1027 {
1028 struct iscsi_sync_state state;
1029
1030 memset(&state, 0, sizeof(state));
1031
1032 if (iscsi_write16_iov_task(iscsi, lun, lba,
1033 data, datalen, blocksize, wrprotect,
1034 dpo, fua, fua_nv, group_number,
1035 scsi_sync_cb, &state, iov, niov) == NULL) {
1036 iscsi_set_error(iscsi,
1037 "Failed to send Write16 command");
1038 return NULL;
1039 }
1040
1041 event_loop(iscsi, &state);
1042
1043 return state.task;
1044 }
1045
1046 struct scsi_task *
iscsi_writeatomic16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int group_number)1047 iscsi_writeatomic16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1048 unsigned char *data, uint32_t datalen, int blocksize,
1049 int wrprotect, int dpo, int fua, int group_number)
1050 {
1051 struct iscsi_sync_state state;
1052
1053 memset(&state, 0, sizeof(state));
1054
1055 if (iscsi_writeatomic16_task(iscsi, lun, lba,
1056 data, datalen, blocksize, wrprotect,
1057 dpo, fua, group_number,
1058 scsi_sync_cb, &state) == NULL) {
1059 iscsi_set_error(iscsi,
1060 "Failed to send WriteAtomic16 command");
1061 return NULL;
1062 }
1063
1064 event_loop(iscsi, &state);
1065
1066 return state.task;
1067 }
1068
1069 struct scsi_task *
iscsi_writeatomic16_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int group_number,struct scsi_iovec * iov,int niov)1070 iscsi_writeatomic16_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1071 unsigned char *data, uint32_t datalen, int blocksize,
1072 int wrprotect, int dpo, int fua, int group_number,
1073 struct scsi_iovec *iov, int niov)
1074 {
1075 struct iscsi_sync_state state;
1076
1077 memset(&state, 0, sizeof(state));
1078
1079 if (iscsi_writeatomic16_iov_task(iscsi, lun, lba,
1080 data, datalen, blocksize, wrprotect,
1081 dpo, fua, group_number,
1082 scsi_sync_cb, &state, iov, niov) == NULL) {
1083 iscsi_set_error(iscsi,
1084 "Failed to send WriteAtomic16 command");
1085 return NULL;
1086 }
1087
1088 event_loop(iscsi, &state);
1089
1090 return state.task;
1091 }
1092
1093 struct scsi_task *
iscsi_orwrite_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number)1094 iscsi_orwrite_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1095 unsigned char *data, uint32_t datalen, int blocksize,
1096 int wrprotect, int dpo, int fua, int fua_nv, int group_number)
1097 {
1098 struct iscsi_sync_state state;
1099
1100 memset(&state, 0, sizeof(state));
1101
1102 if (iscsi_orwrite_task(iscsi, lun, lba,
1103 data, datalen, blocksize, wrprotect,
1104 dpo, fua, fua_nv, group_number,
1105 scsi_sync_cb, &state) == NULL) {
1106 iscsi_set_error(iscsi,
1107 "Failed to send Orwrite command");
1108 return NULL;
1109 }
1110
1111 event_loop(iscsi, &state);
1112
1113 return state.task;
1114 }
1115
1116 struct scsi_task *
iscsi_orwrite_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)1117 iscsi_orwrite_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1118 unsigned char *data, uint32_t datalen, int blocksize,
1119 int wrprotect, int dpo, int fua, int fua_nv, int group_number,
1120 struct scsi_iovec *iov, int niov)
1121 {
1122 struct iscsi_sync_state state;
1123
1124 memset(&state, 0, sizeof(state));
1125
1126 if (iscsi_orwrite_iov_task(iscsi, lun, lba,
1127 data, datalen, blocksize, wrprotect,
1128 dpo, fua, fua_nv, group_number,
1129 scsi_sync_cb, &state, iov, niov) == NULL) {
1130 iscsi_set_error(iscsi,
1131 "Failed to send Orwrite command");
1132 return NULL;
1133 }
1134
1135 event_loop(iscsi, &state);
1136
1137 return state.task;
1138 }
1139
1140 struct scsi_task *
iscsi_compareandwrite_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number)1141 iscsi_compareandwrite_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1142 unsigned char *data, uint32_t datalen, int blocksize,
1143 int wrprotect, int dpo, int fua, int fua_nv, int group_number)
1144 {
1145 struct iscsi_sync_state state;
1146
1147 memset(&state, 0, sizeof(state));
1148
1149 if (iscsi_compareandwrite_task(iscsi, lun, lba,
1150 data, datalen, blocksize, wrprotect,
1151 dpo, fua, fua_nv, group_number,
1152 scsi_sync_cb, &state) == NULL) {
1153 iscsi_set_error(iscsi,
1154 "Failed to send CompareAndWrite command");
1155 return NULL;
1156 }
1157
1158 event_loop(iscsi, &state);
1159
1160 return state.task;
1161 }
1162
1163 struct scsi_task *
iscsi_compareandwrite_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int fua,int fua_nv,int group_number,struct scsi_iovec * iov,int niov)1164 iscsi_compareandwrite_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1165 unsigned char *data, uint32_t datalen, int blocksize,
1166 int wrprotect, int dpo, int fua, int fua_nv, int group_number,
1167 struct scsi_iovec *iov, int niov)
1168 {
1169 struct iscsi_sync_state state;
1170
1171 memset(&state, 0, sizeof(state));
1172
1173 if (iscsi_compareandwrite_iov_task(iscsi, lun, lba,
1174 data, datalen, blocksize, wrprotect,
1175 dpo, fua, fua_nv, group_number,
1176 scsi_sync_cb, &state, iov, niov) == NULL) {
1177 iscsi_set_error(iscsi,
1178 "Failed to send CompareAndWrite command");
1179 return NULL;
1180 }
1181
1182 event_loop(iscsi, &state);
1183
1184 return state.task;
1185 }
1186
1187 struct scsi_task *
iscsi_writeverify10_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number)1188 iscsi_writeverify10_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1189 unsigned char *data, uint32_t datalen, int blocksize,
1190 int wrprotect, int dpo, int bytchk, int group_number)
1191 {
1192 struct iscsi_sync_state state;
1193
1194 memset(&state, 0, sizeof(state));
1195
1196 if (iscsi_writeverify10_task(iscsi, lun, lba, data, datalen, blocksize,
1197 wrprotect, dpo, bytchk, group_number,
1198 scsi_sync_cb, &state) == NULL) {
1199 iscsi_set_error(iscsi,
1200 "Failed to send Writeverify10 command");
1201 return NULL;
1202 }
1203
1204 event_loop(iscsi, &state);
1205
1206 return state.task;
1207 }
1208
1209 struct scsi_task *
iscsi_writeverify10_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number,struct scsi_iovec * iov,int niov)1210 iscsi_writeverify10_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1211 unsigned char *data, uint32_t datalen, int blocksize,
1212 int wrprotect, int dpo, int bytchk, int group_number,
1213 struct scsi_iovec *iov, int niov)
1214 {
1215 struct iscsi_sync_state state;
1216
1217 memset(&state, 0, sizeof(state));
1218
1219 if (iscsi_writeverify10_iov_task(iscsi, lun, lba, data, datalen, blocksize,
1220 wrprotect, dpo, bytchk, group_number,
1221 scsi_sync_cb, &state, iov, niov) == NULL) {
1222 iscsi_set_error(iscsi,
1223 "Failed to send Writeverify10 command");
1224 return NULL;
1225 }
1226
1227 event_loop(iscsi, &state);
1228
1229 return state.task;
1230 }
1231
1232 struct scsi_task *
iscsi_writeverify12_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number)1233 iscsi_writeverify12_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1234 unsigned char *data, uint32_t datalen, int blocksize,
1235 int wrprotect, int dpo, int bytchk, int group_number)
1236 {
1237 struct iscsi_sync_state state;
1238
1239 memset(&state, 0, sizeof(state));
1240
1241 if (iscsi_writeverify12_task(iscsi, lun, lba,
1242 data, datalen, blocksize, wrprotect,
1243 dpo, bytchk, group_number,
1244 scsi_sync_cb, &state) == NULL) {
1245 iscsi_set_error(iscsi,
1246 "Failed to send Writeverify12 command");
1247 return NULL;
1248 }
1249
1250 event_loop(iscsi, &state);
1251
1252 return state.task;
1253 }
1254
1255 struct scsi_task *
iscsi_writeverify12_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number,struct scsi_iovec * iov,int niov)1256 iscsi_writeverify12_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1257 unsigned char *data, uint32_t datalen, int blocksize,
1258 int wrprotect, int dpo, int bytchk, int group_number,
1259 struct scsi_iovec *iov, int niov)
1260 {
1261 struct iscsi_sync_state state;
1262
1263 memset(&state, 0, sizeof(state));
1264
1265 if (iscsi_writeverify12_iov_task(iscsi, lun, lba,
1266 data, datalen, blocksize, wrprotect,
1267 dpo, bytchk, group_number,
1268 scsi_sync_cb, &state, iov, niov) == NULL) {
1269 iscsi_set_error(iscsi,
1270 "Failed to send Writeverify12 command");
1271 return NULL;
1272 }
1273
1274 event_loop(iscsi, &state);
1275
1276 return state.task;
1277 }
1278
1279 struct scsi_task *
iscsi_writeverify16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number)1280 iscsi_writeverify16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1281 unsigned char *data, uint32_t datalen, int blocksize,
1282 int wrprotect, int dpo, int bytchk, int group_number)
1283 {
1284 struct iscsi_sync_state state;
1285
1286 memset(&state, 0, sizeof(state));
1287
1288 if (iscsi_writeverify16_task(iscsi, lun, lba,
1289 data, datalen, blocksize, wrprotect,
1290 dpo, bytchk, group_number,
1291 scsi_sync_cb, &state) == NULL) {
1292 iscsi_set_error(iscsi,
1293 "Failed to send Writeverify16 command");
1294 return NULL;
1295 }
1296
1297 event_loop(iscsi, &state);
1298
1299 return state.task;
1300 }
1301
1302 struct scsi_task *
iscsi_writeverify16_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,int blocksize,int wrprotect,int dpo,int bytchk,int group_number,struct scsi_iovec * iov,int niov)1303 iscsi_writeverify16_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1304 unsigned char *data, uint32_t datalen, int blocksize,
1305 int wrprotect, int dpo, int bytchk, int group_number,
1306 struct scsi_iovec *iov, int niov)
1307 {
1308 struct iscsi_sync_state state;
1309
1310 memset(&state, 0, sizeof(state));
1311
1312 if (iscsi_writeverify16_iov_task(iscsi, lun, lba,
1313 data, datalen, blocksize, wrprotect,
1314 dpo, bytchk, group_number,
1315 scsi_sync_cb, &state, iov, niov) == NULL) {
1316 iscsi_set_error(iscsi,
1317 "Failed to send Writeverify16 command");
1318 return NULL;
1319 }
1320
1321 event_loop(iscsi, &state);
1322
1323 return state.task;
1324 }
1325
1326 struct scsi_task *
iscsi_verify10_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint32_t lba,int vprotect,int dpo,int bytchk,int blocksize)1327 iscsi_verify10_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint32_t lba,
1328 int vprotect, int dpo, int bytchk, int blocksize)
1329 {
1330 struct iscsi_sync_state state;
1331
1332 memset(&state, 0, sizeof(state));
1333
1334 if (iscsi_verify10_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1335 scsi_sync_cb, &state) == NULL) {
1336 iscsi_set_error(iscsi,
1337 "Failed to send Verify10 command");
1338 return NULL;
1339 }
1340
1341 event_loop(iscsi, &state);
1342
1343 return state.task;
1344 }
1345
1346 struct scsi_task *
iscsi_verify10_iov_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint32_t lba,int vprotect,int dpo,int bytchk,int blocksize,struct scsi_iovec * iov,int niov)1347 iscsi_verify10_iov_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint32_t lba,
1348 int vprotect, int dpo, int bytchk, int blocksize, struct scsi_iovec *iov, int niov)
1349 {
1350 struct iscsi_sync_state state;
1351
1352 memset(&state, 0, sizeof(state));
1353
1354 if (iscsi_verify10_iov_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1355 scsi_sync_cb, &state, iov, niov) == NULL) {
1356 iscsi_set_error(iscsi,
1357 "Failed to send Verify10 command");
1358 return NULL;
1359 }
1360
1361 event_loop(iscsi, &state);
1362
1363 return state.task;
1364 }
1365
1366
1367 struct scsi_task *
iscsi_verify12_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint32_t lba,int vprotect,int dpo,int bytchk,int blocksize)1368 iscsi_verify12_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint32_t lba,
1369 int vprotect, int dpo, int bytchk, int blocksize)
1370 {
1371 struct iscsi_sync_state state;
1372
1373 memset(&state, 0, sizeof(state));
1374
1375 if (iscsi_verify12_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1376 scsi_sync_cb, &state) == NULL) {
1377 iscsi_set_error(iscsi,
1378 "Failed to send Verify12 command");
1379 return NULL;
1380 }
1381
1382 event_loop(iscsi, &state);
1383
1384 return state.task;
1385 }
1386
1387 struct scsi_task *
iscsi_verify12_iov_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint32_t lba,int vprotect,int dpo,int bytchk,int blocksize,struct scsi_iovec * iov,int niov)1388 iscsi_verify12_iov_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint32_t lba,
1389 int vprotect, int dpo, int bytchk, int blocksize, struct scsi_iovec *iov, int niov)
1390 {
1391 struct iscsi_sync_state state;
1392
1393 memset(&state, 0, sizeof(state));
1394
1395 if (iscsi_verify12_iov_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1396 scsi_sync_cb, &state, iov, niov) == NULL) {
1397 iscsi_set_error(iscsi,
1398 "Failed to send Verify12 command");
1399 return NULL;
1400 }
1401
1402 event_loop(iscsi, &state);
1403
1404 return state.task;
1405 }
1406
1407 struct scsi_task *
iscsi_verify16_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint64_t lba,int vprotect,int dpo,int bytchk,int blocksize)1408 iscsi_verify16_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint64_t lba,
1409 int vprotect, int dpo, int bytchk, int blocksize)
1410 {
1411 struct iscsi_sync_state state;
1412
1413 memset(&state, 0, sizeof(state));
1414
1415 if (iscsi_verify16_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1416 scsi_sync_cb, &state) == NULL) {
1417 iscsi_set_error(iscsi,
1418 "Failed to send Verify16 command");
1419 return NULL;
1420 }
1421
1422 event_loop(iscsi, &state);
1423
1424 return state.task;
1425 }
1426
1427 struct scsi_task *
iscsi_verify16_iov_sync(struct iscsi_context * iscsi,int lun,unsigned char * data,uint32_t datalen,uint64_t lba,int vprotect,int dpo,int bytchk,int blocksize,struct scsi_iovec * iov,int niov)1428 iscsi_verify16_iov_sync(struct iscsi_context *iscsi, int lun, unsigned char *data, uint32_t datalen, uint64_t lba,
1429 int vprotect, int dpo, int bytchk, int blocksize, struct scsi_iovec *iov, int niov)
1430 {
1431 struct iscsi_sync_state state;
1432
1433 memset(&state, 0, sizeof(state));
1434
1435 if (iscsi_verify16_iov_task(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize,
1436 scsi_sync_cb, &state, iov, niov) == NULL) {
1437 iscsi_set_error(iscsi,
1438 "Failed to send Verify16 command");
1439 return NULL;
1440 }
1441
1442 event_loop(iscsi, &state);
1443
1444 return state.task;
1445 }
1446
1447 struct scsi_task *
iscsi_writesame10_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,uint16_t num_blocks,int anchor,int unmap,int wrprotect,int group)1448 iscsi_writesame10_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1449 unsigned char *data, uint32_t datalen,
1450 uint16_t num_blocks,
1451 int anchor, int unmap, int wrprotect, int group)
1452 {
1453 struct iscsi_sync_state state;
1454
1455 memset(&state, 0, sizeof(state));
1456
1457 if (iscsi_writesame10_task(iscsi, lun, lba,
1458 data, datalen, num_blocks,
1459 anchor, unmap, wrprotect, group,
1460 scsi_sync_cb, &state) == NULL) {
1461 iscsi_set_error(iscsi,
1462 "Failed to send WRITESAME10 command");
1463 return NULL;
1464 }
1465
1466 event_loop(iscsi, &state);
1467
1468 return state.task;
1469 }
1470
1471 struct scsi_task *
iscsi_writesame10_iov_sync(struct iscsi_context * iscsi,int lun,uint32_t lba,unsigned char * data,uint32_t datalen,uint16_t num_blocks,int anchor,int unmap,int wrprotect,int group,struct scsi_iovec * iov,int niov)1472 iscsi_writesame10_iov_sync(struct iscsi_context *iscsi, int lun, uint32_t lba,
1473 unsigned char *data, uint32_t datalen,
1474 uint16_t num_blocks,
1475 int anchor, int unmap, int wrprotect, int group,
1476 struct scsi_iovec *iov, int niov)
1477 {
1478 struct iscsi_sync_state state;
1479
1480 memset(&state, 0, sizeof(state));
1481
1482 if (iscsi_writesame10_iov_task(iscsi, lun, lba,
1483 data, datalen, num_blocks,
1484 anchor, unmap, wrprotect, group,
1485 scsi_sync_cb, &state, iov, niov) == NULL) {
1486 iscsi_set_error(iscsi,
1487 "Failed to send WRITESAME10 command");
1488 return NULL;
1489 }
1490
1491 event_loop(iscsi, &state);
1492
1493 return state.task;
1494 }
1495
1496 struct scsi_task *
iscsi_writesame16_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,uint32_t num_blocks,int anchor,int unmap,int wrprotect,int group)1497 iscsi_writesame16_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1498 unsigned char *data, uint32_t datalen,
1499 uint32_t num_blocks,
1500 int anchor, int unmap, int wrprotect, int group)
1501 {
1502 struct iscsi_sync_state state;
1503
1504 memset(&state, 0, sizeof(state));
1505
1506 if (iscsi_writesame16_task(iscsi, lun, lba,
1507 data, datalen, num_blocks,
1508 anchor, unmap, wrprotect, group,
1509 scsi_sync_cb, &state) == NULL) {
1510 iscsi_set_error(iscsi,
1511 "Failed to send WRITESAME16 command");
1512 return NULL;
1513 }
1514
1515 event_loop(iscsi, &state);
1516
1517 return state.task;
1518 }
1519
1520 struct scsi_task *
iscsi_writesame16_iov_sync(struct iscsi_context * iscsi,int lun,uint64_t lba,unsigned char * data,uint32_t datalen,uint32_t num_blocks,int anchor,int unmap,int wrprotect,int group,struct scsi_iovec * iov,int niov)1521 iscsi_writesame16_iov_sync(struct iscsi_context *iscsi, int lun, uint64_t lba,
1522 unsigned char *data, uint32_t datalen,
1523 uint32_t num_blocks,
1524 int anchor, int unmap, int wrprotect, int group,
1525 struct scsi_iovec *iov, int niov)
1526 {
1527 struct iscsi_sync_state state;
1528
1529 memset(&state, 0, sizeof(state));
1530
1531 if (iscsi_writesame16_iov_task(iscsi, lun, lba,
1532 data, datalen, num_blocks,
1533 anchor, unmap, wrprotect, group,
1534 scsi_sync_cb, &state, iov, niov) == NULL) {
1535 iscsi_set_error(iscsi,
1536 "Failed to send WRITESAME16 command");
1537 return NULL;
1538 }
1539
1540 event_loop(iscsi, &state);
1541
1542 return state.task;
1543 }
1544
1545 struct scsi_task *
iscsi_persistent_reserve_in_sync(struct iscsi_context * iscsi,int lun,int sa,uint16_t xferlen)1546 iscsi_persistent_reserve_in_sync(struct iscsi_context *iscsi, int lun,
1547 int sa, uint16_t xferlen)
1548 {
1549 struct iscsi_sync_state state;
1550
1551 memset(&state, 0, sizeof(state));
1552
1553 if (iscsi_persistent_reserve_in_task(iscsi, lun, sa, xferlen,
1554 scsi_sync_cb, &state) == NULL) {
1555 iscsi_set_error(iscsi,
1556 "Failed to send PERSISTENT_RESERVE_IN command");
1557 return NULL;
1558 }
1559
1560 event_loop(iscsi, &state);
1561
1562 return state.task;
1563 }
1564
1565 struct scsi_task *
iscsi_persistent_reserve_out_sync(struct iscsi_context * iscsi,int lun,int sa,int scope,int type,void * param)1566 iscsi_persistent_reserve_out_sync(struct iscsi_context *iscsi, int lun,
1567 int sa, int scope, int type, void *param)
1568 {
1569 struct iscsi_sync_state state;
1570
1571 memset(&state, 0, sizeof(state));
1572
1573 if (iscsi_persistent_reserve_out_task(iscsi, lun,
1574 sa, scope, type, param,
1575 scsi_sync_cb, &state) == NULL) {
1576 iscsi_set_error(iscsi,
1577 "Failed to send PERSISTENT_RESERVE_OUT command");
1578 return NULL;
1579 }
1580
1581 event_loop(iscsi, &state);
1582
1583 return state.task;
1584 }
1585
1586 struct scsi_task *
iscsi_unmap_sync(struct iscsi_context * iscsi,int lun,int anchor,int group,struct unmap_list * list,int list_len)1587 iscsi_unmap_sync(struct iscsi_context *iscsi, int lun, int anchor, int group,
1588 struct unmap_list *list, int list_len)
1589 {
1590 struct iscsi_sync_state state;
1591
1592 memset(&state, 0, sizeof(state));
1593
1594 if (iscsi_unmap_task(iscsi, lun, anchor, group, list, list_len,
1595 scsi_sync_cb, &state) == NULL) {
1596 iscsi_set_error(iscsi,
1597 "Failed to send UNMAP command");
1598 return NULL;
1599 }
1600
1601 event_loop(iscsi, &state);
1602
1603 return state.task;
1604 }
1605
1606 struct scsi_task *
iscsi_readtoc_sync(struct iscsi_context * iscsi,int lun,int msf,int format,int track_session,int maxsize)1607 iscsi_readtoc_sync(struct iscsi_context *iscsi, int lun, int msf, int format,
1608 int track_session, int maxsize)
1609 {
1610 struct iscsi_sync_state state;
1611
1612 memset(&state, 0, sizeof(state));
1613
1614 if (iscsi_readtoc_task(iscsi, lun, msf, format, track_session,
1615 maxsize, scsi_sync_cb, &state) == NULL) {
1616 iscsi_set_error(iscsi, "Failed to send Read TOC command");
1617 return NULL;
1618 }
1619
1620 event_loop(iscsi, &state);
1621
1622 return state.task;
1623 }
1624
1625 struct scsi_task *
iscsi_reserve6_sync(struct iscsi_context * iscsi,int lun)1626 iscsi_reserve6_sync(struct iscsi_context *iscsi, int lun)
1627 {
1628 struct iscsi_sync_state state;
1629
1630 memset(&state, 0, sizeof(state));
1631
1632 if (iscsi_reserve6_task(iscsi, lun, scsi_sync_cb, &state) == NULL) {
1633 iscsi_set_error(iscsi, "Failed to send RESERVE6 command");
1634 return NULL;
1635 }
1636
1637 event_loop(iscsi, &state);
1638
1639 return state.task;
1640 }
1641
1642 struct scsi_task *
iscsi_release6_sync(struct iscsi_context * iscsi,int lun)1643 iscsi_release6_sync(struct iscsi_context *iscsi, int lun)
1644 {
1645 struct iscsi_sync_state state;
1646
1647 memset(&state, 0, sizeof(state));
1648
1649 if (iscsi_release6_task(iscsi, lun, scsi_sync_cb, &state) == NULL) {
1650 iscsi_set_error(iscsi, "Failed to send RELEASE6 command");
1651 return NULL;
1652 }
1653
1654 event_loop(iscsi, &state);
1655
1656 return state.task;
1657 }
1658
1659 struct scsi_task *
iscsi_report_supported_opcodes_sync(struct iscsi_context * iscsi,int lun,int rctd,int options,int opcode,int sa,uint32_t alloc_len)1660 iscsi_report_supported_opcodes_sync(struct iscsi_context *iscsi, int lun,
1661 int rctd, int options,
1662 int opcode, int sa,
1663 uint32_t alloc_len)
1664 {
1665 struct iscsi_sync_state state;
1666
1667 memset(&state, 0, sizeof(state));
1668
1669 if (iscsi_report_supported_opcodes_task(iscsi, lun, rctd, options, opcode, sa, alloc_len, scsi_sync_cb, &state) == NULL) {
1670 iscsi_set_error(iscsi, "Failed to send MaintenanceIn:"
1671 "Report Supported Opcodes command");
1672 return NULL;
1673 }
1674
1675 event_loop(iscsi, &state);
1676
1677 return state.task;
1678 }
1679
1680 struct scsi_task *
iscsi_receive_copy_results_sync(struct iscsi_context * iscsi,int lun,int sa,int list_id,int alloc_len)1681 iscsi_receive_copy_results_sync(struct iscsi_context *iscsi, int lun,
1682 int sa, int list_id, int alloc_len)
1683 {
1684 struct iscsi_sync_state state;
1685
1686 memset(&state, 0, sizeof(state));
1687
1688 if (iscsi_receive_copy_results_task(iscsi, lun, sa, list_id, alloc_len,
1689 scsi_sync_cb, &state) == NULL) {
1690 iscsi_set_error(iscsi, "Failed to send RECEIVE COPY RESULTS"
1691 " command");
1692 return NULL;
1693 }
1694
1695 event_loop(iscsi, &state);
1696
1697 return state.task;
1698 }
1699
1700 struct scsi_task *
iscsi_extended_copy_sync(struct iscsi_context * iscsi,int lun,struct iscsi_data * param_data)1701 iscsi_extended_copy_sync(struct iscsi_context *iscsi, int lun,
1702 struct iscsi_data *param_data)
1703 {
1704 struct iscsi_sync_state state;
1705
1706 memset(&state, 0, sizeof(state));
1707
1708 if (iscsi_extended_copy_task(iscsi, lun, param_data,
1709 scsi_sync_cb, &state) == NULL) {
1710 iscsi_set_error(iscsi, "Failed to send EXTENDED COPY"
1711 " command");
1712 return NULL;
1713 }
1714
1715 event_loop(iscsi, &state);
1716
1717 return state.task;
1718 }
1719
1720 struct scsi_task *
iscsi_scsi_command_sync(struct iscsi_context * iscsi,int lun,struct scsi_task * task,struct iscsi_data * data)1721 iscsi_scsi_command_sync(struct iscsi_context *iscsi, int lun,
1722 struct scsi_task *task, struct iscsi_data *data)
1723 {
1724 struct iscsi_sync_state state;
1725
1726 memset(&state, 0, sizeof(state));
1727
1728 if (iscsi_scsi_command_async(iscsi, lun, task,
1729 scsi_sync_cb, data, &state) != 0) {
1730 iscsi_set_error(iscsi, "Failed to send SCSI command");
1731 return NULL;
1732 }
1733
1734 event_loop(iscsi, &state);
1735
1736 return state.task;
1737 }
1738
1739
1740 struct scsi_task *
iscsi_modeselect6_sync(struct iscsi_context * iscsi,int lun,int pf,int sp,struct scsi_mode_page * mp)1741 iscsi_modeselect6_sync(struct iscsi_context *iscsi, int lun,
1742 int pf, int sp, struct scsi_mode_page *mp)
1743 {
1744 struct iscsi_sync_state state;
1745
1746 memset(&state, 0, sizeof(state));
1747
1748 if (iscsi_modeselect6_task(iscsi, lun, pf, sp, mp,
1749 scsi_sync_cb, &state) == NULL) {
1750 iscsi_set_error(iscsi,
1751 "Failed to send MODE_SELECT6 command");
1752 return NULL;
1753 }
1754
1755 event_loop(iscsi, &state);
1756
1757 return state.task;
1758 }
1759
1760 struct scsi_task *
iscsi_modeselect10_sync(struct iscsi_context * iscsi,int lun,int pf,int sp,struct scsi_mode_page * mp)1761 iscsi_modeselect10_sync(struct iscsi_context *iscsi, int lun,
1762 int pf, int sp, struct scsi_mode_page *mp)
1763 {
1764 struct iscsi_sync_state state;
1765
1766 memset(&state, 0, sizeof(state));
1767
1768 if (iscsi_modeselect10_task(iscsi, lun, pf, sp, mp,
1769 scsi_sync_cb, &state) == NULL) {
1770 iscsi_set_error(iscsi,
1771 "Failed to send MODE_SELECT10 command");
1772 return NULL;
1773 }
1774
1775 event_loop(iscsi, &state);
1776
1777 return state.task;
1778 }
1779
1780 struct scsi_task *
iscsi_modesense6_sync(struct iscsi_context * iscsi,int lun,int dbd,int pc,int page_code,int sub_page_code,unsigned char alloc_len)1781 iscsi_modesense6_sync(struct iscsi_context *iscsi, int lun, int dbd,
1782 int pc, int page_code, int sub_page_code,
1783 unsigned char alloc_len)
1784 {
1785 struct iscsi_sync_state state;
1786
1787 memset(&state, 0, sizeof(state));
1788
1789 if (iscsi_modesense6_task(iscsi, lun, dbd, pc, page_code, sub_page_code, alloc_len,
1790 scsi_sync_cb, &state) == NULL) {
1791 iscsi_set_error(iscsi,
1792 "Failed to send MODE_SENSE6 command");
1793 return NULL;
1794 }
1795
1796 event_loop(iscsi, &state);
1797
1798 return state.task;
1799 }
1800
1801 struct scsi_task *
iscsi_modesense10_sync(struct iscsi_context * iscsi,int lun,int llbaa,int dbd,int pc,int page_code,int sub_page_code,unsigned char alloc_len)1802 iscsi_modesense10_sync(struct iscsi_context *iscsi, int lun, int llbaa, int dbd,
1803 int pc, int page_code, int sub_page_code,
1804 unsigned char alloc_len)
1805 {
1806 struct iscsi_sync_state state;
1807
1808 memset(&state, 0, sizeof(state));
1809
1810 if (iscsi_modesense10_task(iscsi, lun, llbaa, dbd, pc,
1811 page_code, sub_page_code, alloc_len,
1812 scsi_sync_cb, &state) == NULL) {
1813 iscsi_set_error(iscsi,
1814 "Failed to send MODE_SENSE10 command");
1815 return NULL;
1816 }
1817
1818 event_loop(iscsi, &state);
1819
1820 return state.task;
1821 }
1822
iscsi_free_discovery_data(struct iscsi_context * iscsi _U_,struct iscsi_discovery_address * da)1823 void iscsi_free_discovery_data(struct iscsi_context *iscsi _U_,
1824 struct iscsi_discovery_address *da)
1825 {
1826 while (da) {
1827 struct iscsi_discovery_address *danext = da->next;
1828
1829 while (da->portals) {
1830 struct iscsi_target_portal *ponext = da->portals->next;
1831 free(discard_const(da->portals->portal));
1832 free(da->portals);
1833 da->portals = ponext;
1834 }
1835 free(discard_const(da->target_name));
1836 free(da);
1837 da = danext;
1838 }
1839 }
1840
1841 static void
iscsi_discovery_cb(struct iscsi_context * iscsi _U_,int status,void * command_data,void * private_data)1842 iscsi_discovery_cb(struct iscsi_context *iscsi _U_, int status,
1843 void *command_data, void *private_data)
1844 {
1845 struct iscsi_sync_state *state = private_data;
1846 struct iscsi_discovery_address *da;
1847 struct iscsi_discovery_address *dahead = NULL;
1848 struct iscsi_target_portal *po;
1849
1850 for (da = command_data; da != NULL; da = da->next) {
1851 struct iscsi_discovery_address *datmp;
1852
1853 datmp = malloc(sizeof(struct iscsi_discovery_address));
1854 memset(datmp, 0, sizeof(struct iscsi_discovery_address));
1855 datmp->target_name = strdup(da->target_name);
1856 datmp->next = dahead;
1857 dahead = datmp;
1858
1859 for (po = da->portals; po != NULL; po = po->next) {
1860 struct iscsi_target_portal *potmp;
1861
1862 potmp = malloc(sizeof(struct iscsi_target_portal));
1863 memset(potmp, 0, sizeof(struct iscsi_target_portal));
1864 potmp->portal = strdup(po->portal);
1865
1866 potmp->next = dahead->portals;
1867 dahead->portals = potmp;
1868 }
1869 }
1870
1871 state->status = status;
1872 state->finished = 1;
1873 state->ptr = dahead;
1874 }
1875
1876 struct iscsi_discovery_address *
iscsi_discovery_sync(struct iscsi_context * iscsi)1877 iscsi_discovery_sync(struct iscsi_context *iscsi)
1878 {
1879 struct iscsi_sync_state state;
1880
1881 memset(&state, 0, sizeof(state));
1882
1883 if (iscsi_discovery_async(iscsi, iscsi_discovery_cb, &state) != 0) {
1884 iscsi_set_error(iscsi, "Failed to run discovery. %s",
1885 iscsi_get_error(iscsi));
1886 printf("async discovery call failed\n");
1887 return NULL;
1888 }
1889
1890 event_loop(iscsi, &state);
1891
1892 return state.ptr;
1893 }
1894