storage_backend_iscsi.c 23.5 KB
Newer Older
1 2 3
/*
 * storage_backend_iscsi.c: storage backend for iSCSI handling
 *
E
Eric Blake 已提交
4
 * Copyright (C) 2007-2008, 2010-2012 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34
 * Copyright (C) 2007-2008 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include <sys/socket.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <string.h>
#include <stdio.h>
#include <regex.h>
#include <fcntl.h>
#include <unistd.h>
D
David Allan 已提交
35
#include <sys/stat.h>
36

37
#include "virterror_internal.h"
38
#include "storage_backend_scsi.h"
39 40
#include "storage_backend_iscsi.h"
#include "util.h"
41
#include "memory.h"
D
David Allan 已提交
42
#include "logging.h"
E
Eric Blake 已提交
43
#include "virfile.h"
44
#include "command.h"
45
#include "virrandom.h"
46

47 48
#define VIR_FROM_THIS VIR_FROM_STORAGE

49
static int
50
virStorageBackendISCSITargetIP(const char *hostname,
51 52 53 54 55 56 57
                               char *ipaddr,
                               size_t ipaddrlen)
{
    struct addrinfo hints;
    struct addrinfo *result = NULL;
    int ret;

58
    memset(&hints, 0, sizeof(hints));
59 60 61 62 63 64 65
    hints.ai_flags = AI_ADDRCONFIG;
    hints.ai_family = AF_INET;
    hints.ai_socktype = SOCK_STREAM;
    hints.ai_protocol = 0;

    ret = getaddrinfo(hostname, NULL, &hints, &result);
    if (ret != 0) {
66
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
67 68 69 70 71 72
                              _("host lookup failed %s"),
                              gai_strerror(ret));
        return -1;
    }

    if (result == NULL) {
73
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
74 75 76 77 78 79 80 81
                              _("no IP address for target %s"),
                              hostname);
        return -1;
    }

    if (getnameinfo(result->ai_addr, result->ai_addrlen,
                    ipaddr, ipaddrlen, NULL, 0,
                    NI_NUMERICHOST) < 0) {
82
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
83 84 85 86 87 88 89 90 91 92
                              _("cannot format ip addr for %s"),
                              hostname);
        freeaddrinfo(result);
        return -1;
    }

    freeaddrinfo(result);
    return 0;
}

93 94 95 96 97 98
static char *
virStorageBackendISCSIPortal(virStoragePoolSourcePtr source)
{
    char ipaddr[NI_MAXHOST];
    char *portal;

99 100 101 102 103 104 105
    if (source->nhost != 1) {
        virStorageReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                              _("Expected exactly 1 host for the storage pool"));
        return NULL;
    }

    if (virStorageBackendISCSITargetIP(source->hosts[0].name,
106 107 108 109
                                       ipaddr, sizeof(ipaddr)) < 0)
        return NULL;

    if (virAsprintf(&portal, "%s:%d,1", ipaddr,
110 111
                    source->hosts[0].port ?
                    source->hosts[0].port : 3260) < 0) {
112 113 114 115 116 117 118 119
        virReportOOMError();
        return NULL;
    }

    return portal;
}


120
static int
121
virStorageBackendISCSIExtractSession(virStoragePoolObjPtr pool,
122 123 124 125 126 127 128
                                     char **const groups,
                                     void *data)
{
    char **session = data;

    if (STREQ(groups[1], pool->def->source.devices[0].path)) {
        if ((*session = strdup(groups[0])) == NULL) {
129
            virReportOOMError();
130 131 132 133 134 135 136 137
            return -1;
        }
    }

    return 0;
}

static char *
138
virStorageBackendISCSISession(virStoragePoolObjPtr pool,
139
                              int probe)
140 141
{
    /*
142
     * # iscsiadm --mode session
143 144 145 146 147 148 149 150 151 152 153 154 155
     * tcp: [1] 192.168.122.170:3260,1 demo-tgt-b
     * tcp: [2] 192.168.122.170:3260,1 demo-tgt-a
     *
     * Pull out 2nd and 4th fields
     */
    const char *regexes[] = {
        "^tcp:\\s+\\[(\\S+)\\]\\s+\\S+\\s+(\\S+)\\s*$"
    };
    int vars[] = {
        2,
    };
    char *session = NULL;

156 157
    virCommandPtr cmd = virCommandNewArgList(ISCSIADM, "--mode", "session", NULL);

158 159 160 161
    /* Note that we ignore the exitstatus.  Older versions of iscsiadm tools
     * returned an exit status of > 0, even if they succeeded.  We will just
     * rely on whether session got filled in properly.
     */
162
    if (virStorageBackendRunProgRegex(pool,
163
                                      cmd,
164 165 166 167
                                      1,
                                      regexes,
                                      vars,
                                      virStorageBackendISCSIExtractSession,
168
                                      &session, NULL) < 0)
169
        goto cleanup;
170

171 172
    if (session == NULL &&
        !probe) {
173
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
174
                              "%s", _("cannot find session"));
175
        goto cleanup;
176 177
    }

178 179
cleanup:
    virCommandFree(cmd);
180 181 182
    return session;
}

D
David Allan 已提交
183 184 185 186

#define LINE_SIZE 4096

static int
187
virStorageBackendIQNFound(const char *initiatoriqn,
D
David Allan 已提交
188 189 190 191 192
                          char **ifacename)
{
    int ret = IQN_MISSING, fd = -1;
    char ebuf[64];
    FILE *fp = NULL;
E
Eric Blake 已提交
193
    char *line = NULL, *newline = NULL, *iqn = NULL, *token = NULL;
194 195
    virCommandPtr cmd = virCommandNewArgList(ISCSIADM,
                                             "--mode", "iface", NULL);
D
David Allan 已提交
196 197 198

    if (VIR_ALLOC_N(line, LINE_SIZE) != 0) {
        ret = IQN_ERROR;
199
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
D
David Allan 已提交
200
                              _("Could not allocate memory for output of '%s'"),
201
                              ISCSIADM);
D
David Allan 已提交
202 203 204 205 206
        goto out;
    }

    memset(line, 0, LINE_SIZE);

207 208
    virCommandSetOutputFD(cmd, &fd);
    if (virCommandRunAsync(cmd, NULL) < 0) {
D
David Allan 已提交
209 210 211 212
        ret = IQN_ERROR;
        goto out;
    }

213
    if ((fp = VIR_FDOPEN(fd, "r")) == NULL) {
214
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
D
David Allan 已提交
215 216
                              _("Failed to open stream for file descriptor "
                                "when reading output from '%s': '%s'"),
217
                              ISCSIADM, virStrerror(errno, ebuf, sizeof(ebuf)));
D
David Allan 已提交
218 219 220 221 222 223 224 225
        ret = IQN_ERROR;
        goto out;
    }

    while (fgets(line, LINE_SIZE, fp) != NULL) {
        newline = strrchr(line, '\n');
        if (newline == NULL) {
            ret = IQN_ERROR;
226
            virStorageReportError(VIR_ERR_INTERNAL_ERROR,
D
David Allan 已提交
227 228
                                  _("Unexpected line > %d characters "
                                    "when parsing output of '%s'"),
229
                                  LINE_SIZE, ISCSIADM);
D
David Allan 已提交
230 231 232 233 234 235 236 237 238 239
            goto out;
        }
        *newline = '\0';

        iqn = strrchr(line, ',');
        if (iqn == NULL) {
            continue;
        }
        iqn++;

240
        if (STREQ(iqn, initiatoriqn)) {
E
Eric Blake 已提交
241 242 243 244 245 246 247 248 249
            token = strchr(line, ' ');
            if (!token) {
                ret = IQN_ERROR;
                virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                                      _("Missing space when parsing output "
                                        "of '%s'"), ISCSIADM);
                goto out;
            }
            *ifacename = strndup(line, token - line);
D
David Allan 已提交
250 251
            if (*ifacename == NULL) {
                ret = IQN_ERROR;
252
                virReportOOMError();
D
David Allan 已提交
253 254 255 256 257 258 259 260
                goto out;
            }
            VIR_DEBUG("Found interface '%s' with IQN '%s'", *ifacename, iqn);
            ret = IQN_FOUND;
            break;
        }
    }

261 262 263
    if (virCommandWait(cmd, NULL) < 0)
        ret = IQN_ERROR;

D
David Allan 已提交
264 265
out:
    if (ret == IQN_MISSING) {
266
        VIR_DEBUG("Could not find interface with IQN '%s'", iqn);
D
David Allan 已提交
267 268 269
    }

    VIR_FREE(line);
270 271
    VIR_FORCE_FCLOSE(fp);
    VIR_FORCE_CLOSE(fd);
272
    virCommandFree(cmd);
D
David Allan 已提交
273 274 275 276 277 278

    return ret;
}


static int
279
virStorageBackendCreateIfaceIQN(const char *initiatoriqn,
280
                                char **ifacename)
D
David Allan 已提交
281 282
{
    int ret = -1, exitstatus = -1;
283 284
    char *temp_ifacename;
    virCommandPtr cmd = NULL;
D
David Allan 已提交
285

286 287 288 289 290 291
    if (virAsprintf(&temp_ifacename,
                    "libvirt-iface-%08llx",
                    (unsigned long long)virRandomBits(30)) < 0) {
        virReportOOMError();
        return -1;
    }
D
David Allan 已提交
292 293

    VIR_DEBUG("Attempting to create interface '%s' with IQN '%s'",
294
              temp_ifacename, initiatoriqn);
D
David Allan 已提交
295

296 297 298 299 300
    cmd = virCommandNewArgList(ISCSIADM,
                               "--mode", "iface",
                               "--interface", temp_ifacename,
                               "--op", "new",
                               NULL);
D
David Allan 已提交
301 302 303 304
    /* Note that we ignore the exitstatus.  Older versions of iscsiadm
     * tools returned an exit status of > 0, even if they succeeded.
     * We will just rely on whether the interface got created
     * properly. */
305
    if (virCommandRun(cmd, &exitstatus) < 0) {
306
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
D
David Allan 已提交
307
                              _("Failed to run command '%s' to create new iscsi interface"),
308 309
                              ISCSIADM);
        goto cleanup;
D
David Allan 已提交
310
    }
311
    virCommandFree(cmd);
D
David Allan 已提交
312

313 314 315 316 317 318 319 320
    cmd = virCommandNewArgList(ISCSIADM,
                               "--mode", "iface",
                               "--interface", temp_ifacename,
                               "--op", "update",
                               "--name", "iface.initiatorname",
                               "--value",
                               initiatoriqn,
                               NULL);
D
David Allan 已提交
321 322 323
    /* Note that we ignore the exitstatus.  Older versions of iscsiadm tools
     * returned an exit status of > 0, even if they succeeded.  We will just
     * rely on whether iface file got updated properly. */
324
    if (virCommandRun(cmd, &exitstatus) < 0) {
325
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
D
David Allan 已提交
326
                              _("Failed to run command '%s' to update iscsi interface with IQN '%s'"),
327 328
                              ISCSIADM, initiatoriqn);
        goto cleanup;
D
David Allan 已提交
329 330 331
    }

    /* Check again to make sure the interface was created. */
332
    if (virStorageBackendIQNFound(initiatoriqn, ifacename) != IQN_FOUND) {
D
David Allan 已提交
333 334
        VIR_DEBUG("Failed to find interface '%s' with IQN '%s' "
                  "after attempting to create it",
335
                  &temp_ifacename[0], initiatoriqn);
336
        goto cleanup;
D
David Allan 已提交
337 338
    } else {
        VIR_DEBUG("Interface '%s' with IQN '%s' was created successfully",
339
                  *ifacename, initiatoriqn);
D
David Allan 已提交
340 341 342 343
    }

    ret = 0;

344 345 346
cleanup:
    virCommandFree(cmd);
    VIR_FREE(temp_ifacename);
D
David Allan 已提交
347 348 349 350 351 352
    if (ret != 0)
        VIR_FREE(*ifacename);
    return ret;
}


353

D
David Allan 已提交
354
static int
355 356 357 358
virStorageBackendISCSIConnection(const char *portal,
                                 const char *initiatoriqn,
                                 const char *target,
                                 const char **extraargv)
D
David Allan 已提交
359 360
{
    int ret = -1;
361 362 363 364 365 366 367
    const char *const baseargv[] = {
        ISCSIADM,
        "--mode", "node",
        "--portal", portal,
        "--targetname", target,
        NULL
    };
368
    virCommandPtr cmd;
D
David Allan 已提交
369 370
    char *ifacename = NULL;

371 372
    cmd = virCommandNewArgs(baseargv);
    virCommandAddArgSet(cmd, extraargv);
D
David Allan 已提交
373

374 375 376 377 378 379
    if (initiatoriqn) {
        switch (virStorageBackendIQNFound(initiatoriqn, &ifacename)) {
        case IQN_FOUND:
            VIR_DEBUG("ifacename: '%s'", ifacename);
            break;
        case IQN_MISSING:
380 381
            if (virStorageBackendCreateIfaceIQN(initiatoriqn,
                                                &ifacename) != 0) {
382 383 384 385 386 387 388
                goto cleanup;
            }
            break;
        case IQN_ERROR:
        default:
            goto cleanup;
        }
389
        virCommandAddArgList(cmd, "--interface", ifacename, NULL);
D
David Allan 已提交
390
    }
391

392
    if (virCommandRun(cmd, NULL) < 0)
393
        goto cleanup;
D
David Allan 已提交
394 395 396

    ret = 0;

397
cleanup:
398
    virCommandFree(cmd);
D
David Allan 已提交
399 400 401
    VIR_FREE(ifacename);

    return ret;
402 403
}

404

405
static int
406
virStorageBackendISCSIFindLUs(virStoragePoolObjPtr pool,
407
                              const char *session)
408
{
409
    char *sysfs_path;
410 411
    int retval = 0;
    uint32_t host;
412

413 414 415 416 417
    if (virAsprintf(&sysfs_path,
                    "/sys/class/iscsi_session/session%s/device", session) < 0) {
        virReportOOMError();
        return -1;
    }
418

419
    if (virStorageBackendSCSIGetHostNumber(sysfs_path, &host) < 0) {
420
        virReportSystemError(errno,
421 422
                             _("Failed to get host number for iSCSI session "
                               "with path '%s'"),
423
                             sysfs_path);
424
        retval = -1;
425 426
    }

427
    if (virStorageBackendSCSIFindLUs(pool, host) < 0) {
428
        virReportSystemError(errno,
429 430
                             _("Failed to find LUs on host %u"), host);
        retval = -1;
431 432
    }

433 434
    VIR_FREE(sysfs_path);

435 436
    return retval;
}
437 438

static int
439
virStorageBackendISCSIRescanLUNs(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
440 441
                                 const char *session)
{
442 443 444 445 446 447 448 449
    virCommandPtr cmd = virCommandNewArgList(ISCSIADM,
                                             "--mode", "session",
                                             "-r", session,
                                             "-R",
                                             NULL);
    int ret = virCommandRun(cmd, NULL);
    virCommandFree(cmd);
    return ret;
450 451
}

452 453 454 455
struct virStorageBackendISCSITargetList {
    size_t ntargets;
    char **targets;
};
456 457

static int
458 459 460
virStorageBackendISCSIGetTargets(virStoragePoolObjPtr pool ATTRIBUTE_UNUSED,
                                 char **const groups,
                                 void *data)
461
{
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514
    struct virStorageBackendISCSITargetList *list = data;
    char *target;

    if (!(target = strdup(groups[1]))) {
        virReportOOMError();
        return -1;
    }

    if (VIR_REALLOC_N(list->targets, list->ntargets + 1) < 0) {
        VIR_FREE(target);
        virReportOOMError();
        return -1;
    }

    list->targets[list->ntargets] = target;
    list->ntargets++;

    return 0;
}

static int
virStorageBackendISCSITargetAutologin(const char *portal,
                                      const char *initiatoriqn,
                                      const char *target,
                                      bool enable)
{
    const char *extraargv[] = { "--op", "update",
                                "--name", "node.startup",
                                "--value", enable ? "automatic" : "manual",
                                NULL };

    return virStorageBackendISCSIConnection(portal, initiatoriqn, target, extraargv);
}


static int
virStorageBackendISCSIScanTargets(const char *portal,
                                  const char *initiatoriqn,
                                  size_t *ntargetsret,
                                  char ***targetsret)
{
    /**
     *
     * The output of sendtargets is very simple, just two columns,
     * portal then target name
     *
     * 192.168.122.185:3260,1 iqn.2004-04.com:fedora14:iscsi.demo0.bf6d84
     * 192.168.122.185:3260,1 iqn.2004-04.com:fedora14:iscsi.demo1.bf6d84
     * 192.168.122.185:3260,1 iqn.2004-04.com:fedora14:iscsi.demo2.bf6d84
     * 192.168.122.185:3260,1 iqn.2004-04.com:fedora14:iscsi.demo3.bf6d84
     */
    const char *regexes[] = {
        "^\\s*(\\S+)\\s+(\\S+)\\s*$"
515
    };
516 517
    int vars[] = { 2 };
    struct virStorageBackendISCSITargetList list;
518 519 520 521 522 523 524
    size_t i;
    int ret = -1;
    virCommandPtr cmd = virCommandNewArgList(ISCSIADM,
                                             "--mode", "discovery",
                                             "--type", "sendtargets",
                                             "--portal", portal,
                                             NULL);
525 526 527 528

    memset(&list, 0, sizeof(list));

    if (virStorageBackendRunProgRegex(NULL, /* No pool for callback */
529
                                      cmd,
530 531 532 533
                                      1,
                                      regexes,
                                      vars,
                                      virStorageBackendISCSIGetTargets,
534 535
                                      &list, NULL) < 0)
        goto cleanup;
536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558

    for (i = 0 ; i < list.ntargets ; i++) {
        /* We have to ignore failure, because we can't undo
         * the results of 'sendtargets', unless we go scrubbing
         * around in the dirt in /var/lib/iscsi.
         */
        if (virStorageBackendISCSITargetAutologin(portal,
                                                  initiatoriqn,
                                                  list.targets[i], false) < 0)
            VIR_WARN("Unable to disable auto-login on iSCSI target %s: %s",
                     portal, list.targets[i]);
    }

    if (ntargetsret && targetsret) {
        *ntargetsret = list.ntargets;
        *targetsret = list.targets;
    } else {
        for (i = 0 ; i < list.ntargets ; i++) {
            VIR_FREE(list.targets[i]);
        }
        VIR_FREE(list.targets);
    }

559 560 561 562
    ret = 0;
cleanup:
    virCommandFree(cmd);
    return ret;
563 564 565
}


566 567 568
static char *
virStorageBackendISCSIFindPoolSources(virConnectPtr conn ATTRIBUTE_UNUSED,
                                      const char *srcSpec,
E
Eric Blake 已提交
569
                                      unsigned int flags)
570 571 572 573 574 575 576 577 578 579 580 581 582
{
    virStoragePoolSourcePtr source = NULL;
    size_t ntargets = 0;
    char **targets = NULL;
    char *ret = NULL;
    int i;
    virStoragePoolSourceList list = {
        .type = VIR_STORAGE_POOL_ISCSI,
        .nsources = 0,
        .sources = NULL
    };
    char *portal = NULL;

E
Eric Blake 已提交
583 584
    virCheckFlags(0, NULL);

585 586 587 588
    if (!(source = virStoragePoolDefParseSourceString(srcSpec,
                                                      list.type)))
        return NULL;

589 590 591 592 593 594
    if (source->nhost != 1) {
        virStorageReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                              _("Expected exactly 1 host for the storage pool"));
        goto cleanup;
    }

595 596 597 598 599 600 601 602 603 604 605 606 607 608
    if (!(portal = virStorageBackendISCSIPortal(source)))
        goto cleanup;

    if (virStorageBackendISCSIScanTargets(portal,
                                          source->initiator.iqn,
                                          &ntargets, &targets) < 0)
        goto cleanup;

    if (VIR_ALLOC_N(list.sources, ntargets) < 0) {
        virReportOOMError();
        goto cleanup;
    }

    for (i = 0 ; i < ntargets ; i++) {
E
Eric Blake 已提交
609 610
        if (VIR_ALLOC_N(list.sources[i].devices, 1) < 0 ||
            VIR_ALLOC_N(list.sources[i].hosts, 1) < 0) {
611 612 613
            virReportOOMError();
            goto cleanup;
        }
E
Eric Blake 已提交
614 615
        list.sources[i].nhost = 1;
        list.sources[i].hosts[0] = source->hosts[0];
616 617 618 619 620 621 622 623 624 625 626 627 628
        list.sources[i].initiator = source->initiator;
        list.sources[i].ndevice = 1;
        list.sources[i].devices[0].path = targets[i];
        list.nsources++;
    }

    if (!(ret = virStoragePoolSourceListFormat(&list))) {
        virReportOOMError();
        goto cleanup;
    }

cleanup:
    if (list.sources) {
E
Eric Blake 已提交
629 630
        for (i = 0 ; i < ntargets ; i++) {
            VIR_FREE(list.sources[i].hosts);
631
            VIR_FREE(list.sources[i].devices);
E
Eric Blake 已提交
632
        }
633 634 635 636 637 638 639 640 641 642
        VIR_FREE(list.sources);
    }
    for (i = 0 ; i < ntargets ; i++)
        VIR_FREE(targets[i]);
    VIR_FREE(targets);
    VIR_FREE(portal);
    virStoragePoolSourceFree(source);
    return ret;
}

643 644 645 646 647 648 649 650 651 652
static int
virStorageBackendISCSICheckPool(virConnectPtr conn ATTRIBUTE_UNUSED,
                                virStoragePoolObjPtr pool,
                                bool *isActive)
{
    char *session = NULL;
    int ret = -1;

    *isActive = false;

653 654 655 656 657 658 659
    if (pool->def->source.nhost != 1) {
         virStorageReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("Expected exactly 1 host for the storage pool"));
        return -1;
    }

    if (pool->def->source.hosts[0].name == NULL) {
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                              "%s", _("missing source host"));
        return -1;
    }

    if (pool->def->source.ndevice != 1 ||
        pool->def->source.devices[0].path == NULL) {
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
                              "%s", _("missing source device"));
        return -1;
    }

    if ((session = virStorageBackendISCSISession(pool, 1)) != NULL) {
        *isActive = true;
        VIR_FREE(session);
    }
    ret = 0;

    return ret;
}


682
static int
683
virStorageBackendISCSIStartPool(virConnectPtr conn ATTRIBUTE_UNUSED,
684 685 686
                                virStoragePoolObjPtr pool)
{
    char *portal = NULL;
687 688 689
    char *session = NULL;
    int ret = -1;
    const char *loginargv[] = { "--login", NULL };
690

691 692 693 694 695 696 697
    if (pool->def->source.nhost != 1) {
         virStorageReportError(VIR_ERR_CONFIG_UNSUPPORTED, "%s",
                               _("Expected exactly 1 host for the storage pool"));
        return -1;
    }

    if (pool->def->source.hosts[0].name == NULL) {
698
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
699
                              "%s", _("missing source host"));
700 701 702 703 704
        return -1;
    }

    if (pool->def->source.ndevice != 1 ||
        pool->def->source.devices[0].path == NULL) {
705
        virStorageReportError(VIR_ERR_INTERNAL_ERROR,
J
Jim Meyering 已提交
706
                              "%s", _("missing source device"));
707 708 709
        return -1;
    }

710
    if ((session = virStorageBackendISCSISession(pool, 1)) == NULL) {
711 712 713 714 715 716
        if ((portal = virStorageBackendISCSIPortal(&pool->def->source)) == NULL)
            goto cleanup;
        /*
         * iscsiadm doesn't let you login to a target, unless you've
         * first issued a 'sendtargets' command to the portal :-(
         */
717 718 719
        if (virStorageBackendISCSIScanTargets(portal,
                                              pool->def->source.initiator.iqn,
                                              NULL, NULL) < 0)
720 721 722 723 724 725 726
            goto cleanup;

        if (virStorageBackendISCSIConnection(portal,
                                             pool->def->source.initiator.iqn,
                                             pool->def->source.devices[0].path,
                                             loginargv) < 0)
            goto cleanup;
727
    }
728 729 730 731 732
    ret = 0;

cleanup:
    VIR_FREE(session);
    return ret;
733 734 735
}

static int
736
virStorageBackendISCSIRefreshPool(virConnectPtr conn ATTRIBUTE_UNUSED,
737 738 739 740 741 742
                                  virStoragePoolObjPtr pool)
{
    char *session = NULL;

    pool->def->allocation = pool->def->capacity = pool->def->available = 0;

743
    if ((session = virStorageBackendISCSISession(pool, 0)) == NULL)
744
        goto cleanup;
745
    if (virStorageBackendISCSIRescanLUNs(pool, session) < 0)
746
        goto cleanup;
747
    if (virStorageBackendISCSIFindLUs(pool, session) < 0)
748
        goto cleanup;
749
    VIR_FREE(session);
750 751 752 753

    return 0;

 cleanup:
754
    VIR_FREE(session);
755 756 757 758 759
    return -1;
}


static int
760
virStorageBackendISCSIStopPool(virConnectPtr conn ATTRIBUTE_UNUSED,
761 762
                               virStoragePoolObjPtr pool)
{
763
    const char *logoutargv[] = { "--logout", NULL };
764
    char *portal;
765
    int ret = -1;
766

767
    if ((portal = virStorageBackendISCSIPortal(&pool->def->source)) == NULL)
768 769
        return -1;

770 771 772 773 774 775
    if (virStorageBackendISCSIConnection(portal,
                                         pool->def->source.initiator.iqn,
                                         pool->def->source.devices[0].path,
                                         logoutargv) < 0)
        goto cleanup;
    ret = 0;
776

777 778 779
cleanup:
    VIR_FREE(portal);
    return ret;
780 781 782
}

virStorageBackend virStorageBackendISCSI = {
783
    .type = VIR_STORAGE_POOL_ISCSI,
784

785
    .checkPool = virStorageBackendISCSICheckPool,
786 787 788
    .startPool = virStorageBackendISCSIStartPool,
    .refreshPool = virStorageBackendISCSIRefreshPool,
    .stopPool = virStorageBackendISCSIStopPool,
789
    .findPoolSources = virStorageBackendISCSIFindPoolSources,
790
};