Statistics
| Branch: | Revision:

root / qga / commands-posix.c @ 1ab516ed

History | View | Annotate | Download (26.1 kB)

1
/*
2
 * QEMU Guest Agent POSIX-specific command implementations
3
 *
4
 * Copyright IBM Corp. 2011
5
 *
6
 * Authors:
7
 *  Michael Roth      <mdroth@linux.vnet.ibm.com>
8
 *  Michal Privoznik  <mprivozn@redhat.com>
9
 *
10
 * This work is licensed under the terms of the GNU GPL, version 2 or later.
11
 * See the COPYING file in the top-level directory.
12
 */
13

    
14
#include <glib.h>
15
#include <sys/types.h>
16
#include <sys/ioctl.h>
17
#include <sys/wait.h>
18
#include "qga/guest-agent-core.h"
19
#include "qga-qmp-commands.h"
20
#include "qerror.h"
21
#include "qemu-queue.h"
22
#include "host-utils.h"
23

    
24
#ifndef CONFIG_HAS_ENVIRON
25
#ifdef __APPLE__
26
#include <crt_externs.h>
27
#define environ (*_NSGetEnviron())
28
#else
29
extern char **environ;
30
#endif
31
#endif
32

    
33
#if defined(__linux__)
34
#include <mntent.h>
35
#include <linux/fs.h>
36
#include <ifaddrs.h>
37
#include <arpa/inet.h>
38
#include <sys/socket.h>
39
#include <net/if.h>
40

    
41
#ifdef FIFREEZE
42
#define CONFIG_FSFREEZE
43
#endif
44
#ifdef FITRIM
45
#define CONFIG_FSTRIM
46
#endif
47
#endif
48

    
49
void qmp_guest_shutdown(bool has_mode, const char *mode, Error **err)
50
{
51
    const char *shutdown_flag;
52
    pid_t rpid, pid;
53
    int status;
54

    
55
    slog("guest-shutdown called, mode: %s", mode);
56
    if (!has_mode || strcmp(mode, "powerdown") == 0) {
57
        shutdown_flag = "-P";
58
    } else if (strcmp(mode, "halt") == 0) {
59
        shutdown_flag = "-H";
60
    } else if (strcmp(mode, "reboot") == 0) {
61
        shutdown_flag = "-r";
62
    } else {
63
        error_set(err, QERR_INVALID_PARAMETER_VALUE, "mode",
64
                  "halt|powerdown|reboot");
65
        return;
66
    }
67

    
68
    pid = fork();
69
    if (pid == 0) {
70
        /* child, start the shutdown */
71
        setsid();
72
        reopen_fd_to_null(0);
73
        reopen_fd_to_null(1);
74
        reopen_fd_to_null(2);
75

    
76
        execle("/sbin/shutdown", "shutdown", shutdown_flag, "+0",
77
               "hypervisor initiated shutdown", (char*)NULL, environ);
78
        _exit(EXIT_FAILURE);
79
    } else if (pid < 0) {
80
        goto exit_err;
81
    }
82

    
83
    do {
84
        rpid = waitpid(pid, &status, 0);
85
    } while (rpid == -1 && errno == EINTR);
86
    if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) {
87
        return;
88
    }
89

    
90
exit_err:
91
    error_set(err, QERR_UNDEFINED_ERROR);
92
}
93

    
94
typedef struct GuestFileHandle {
95
    uint64_t id;
96
    FILE *fh;
97
    QTAILQ_ENTRY(GuestFileHandle) next;
98
} GuestFileHandle;
99

    
100
static struct {
101
    QTAILQ_HEAD(, GuestFileHandle) filehandles;
102
} guest_file_state;
103

    
104
static void guest_file_handle_add(FILE *fh)
105
{
106
    GuestFileHandle *gfh;
107

    
108
    gfh = g_malloc0(sizeof(GuestFileHandle));
109
    gfh->id = fileno(fh);
110
    gfh->fh = fh;
111
    QTAILQ_INSERT_TAIL(&guest_file_state.filehandles, gfh, next);
112
}
113

    
114
static GuestFileHandle *guest_file_handle_find(int64_t id)
115
{
116
    GuestFileHandle *gfh;
117

    
118
    QTAILQ_FOREACH(gfh, &guest_file_state.filehandles, next)
119
    {
120
        if (gfh->id == id) {
121
            return gfh;
122
        }
123
    }
124

    
125
    return NULL;
126
}
127

    
128
int64_t qmp_guest_file_open(const char *path, bool has_mode, const char *mode, Error **err)
129
{
130
    FILE *fh;
131
    int fd;
132
    int64_t ret = -1;
133

    
134
    if (!has_mode) {
135
        mode = "r";
136
    }
137
    slog("guest-file-open called, filepath: %s, mode: %s", path, mode);
138
    fh = fopen(path, mode);
139
    if (!fh) {
140
        error_set(err, QERR_OPEN_FILE_FAILED, path);
141
        return -1;
142
    }
143

    
144
    /* set fd non-blocking to avoid common use cases (like reading from a
145
     * named pipe) from hanging the agent
146
     */
147
    fd = fileno(fh);
148
    ret = fcntl(fd, F_GETFL);
149
    ret = fcntl(fd, F_SETFL, ret | O_NONBLOCK);
150
    if (ret == -1) {
151
        error_set(err, QERR_QGA_COMMAND_FAILED, "fcntl() failed");
152
        fclose(fh);
153
        return -1;
154
    }
155

    
156
    guest_file_handle_add(fh);
157
    slog("guest-file-open, handle: %d", fd);
158
    return fd;
159
}
160

    
161
void qmp_guest_file_close(int64_t handle, Error **err)
162
{
163
    GuestFileHandle *gfh = guest_file_handle_find(handle);
164
    int ret;
165

    
166
    slog("guest-file-close called, handle: %ld", handle);
167
    if (!gfh) {
168
        error_set(err, QERR_FD_NOT_FOUND, "handle");
169
        return;
170
    }
171

    
172
    ret = fclose(gfh->fh);
173
    if (ret == -1) {
174
        error_set(err, QERR_QGA_COMMAND_FAILED, "fclose() failed");
175
        return;
176
    }
177

    
178
    QTAILQ_REMOVE(&guest_file_state.filehandles, gfh, next);
179
    g_free(gfh);
180
}
181

    
182
struct GuestFileRead *qmp_guest_file_read(int64_t handle, bool has_count,
183
                                          int64_t count, Error **err)
184
{
185
    GuestFileHandle *gfh = guest_file_handle_find(handle);
186
    GuestFileRead *read_data = NULL;
187
    guchar *buf;
188
    FILE *fh;
189
    size_t read_count;
190

    
191
    if (!gfh) {
192
        error_set(err, QERR_FD_NOT_FOUND, "handle");
193
        return NULL;
194
    }
195

    
196
    if (!has_count) {
197
        count = QGA_READ_COUNT_DEFAULT;
198
    } else if (count < 0) {
199
        error_set(err, QERR_INVALID_PARAMETER, "count");
200
        return NULL;
201
    }
202

    
203
    fh = gfh->fh;
204
    buf = g_malloc0(count+1);
205
    read_count = fread(buf, 1, count, fh);
206
    if (ferror(fh)) {
207
        slog("guest-file-read failed, handle: %ld", handle);
208
        error_set(err, QERR_QGA_COMMAND_FAILED, "fread() failed");
209
    } else {
210
        buf[read_count] = 0;
211
        read_data = g_malloc0(sizeof(GuestFileRead));
212
        read_data->count = read_count;
213
        read_data->eof = feof(fh);
214
        if (read_count) {
215
            read_data->buf_b64 = g_base64_encode(buf, read_count);
216
        }
217
    }
218
    g_free(buf);
219
    clearerr(fh);
220

    
221
    return read_data;
222
}
223

    
224
GuestFileWrite *qmp_guest_file_write(int64_t handle, const char *buf_b64,
225
                                     bool has_count, int64_t count, Error **err)
226
{
227
    GuestFileWrite *write_data = NULL;
228
    guchar *buf;
229
    gsize buf_len;
230
    int write_count;
231
    GuestFileHandle *gfh = guest_file_handle_find(handle);
232
    FILE *fh;
233

    
234
    if (!gfh) {
235
        error_set(err, QERR_FD_NOT_FOUND, "handle");
236
        return NULL;
237
    }
238

    
239
    fh = gfh->fh;
240
    buf = g_base64_decode(buf_b64, &buf_len);
241

    
242
    if (!has_count) {
243
        count = buf_len;
244
    } else if (count < 0 || count > buf_len) {
245
        g_free(buf);
246
        error_set(err, QERR_INVALID_PARAMETER, "count");
247
        return NULL;
248
    }
249

    
250
    write_count = fwrite(buf, 1, count, fh);
251
    if (ferror(fh)) {
252
        slog("guest-file-write failed, handle: %ld", handle);
253
        error_set(err, QERR_QGA_COMMAND_FAILED, "fwrite() error");
254
    } else {
255
        write_data = g_malloc0(sizeof(GuestFileWrite));
256
        write_data->count = write_count;
257
        write_data->eof = feof(fh);
258
    }
259
    g_free(buf);
260
    clearerr(fh);
261

    
262
    return write_data;
263
}
264

    
265
struct GuestFileSeek *qmp_guest_file_seek(int64_t handle, int64_t offset,
266
                                          int64_t whence, Error **err)
267
{
268
    GuestFileHandle *gfh = guest_file_handle_find(handle);
269
    GuestFileSeek *seek_data = NULL;
270
    FILE *fh;
271
    int ret;
272

    
273
    if (!gfh) {
274
        error_set(err, QERR_FD_NOT_FOUND, "handle");
275
        return NULL;
276
    }
277

    
278
    fh = gfh->fh;
279
    ret = fseek(fh, offset, whence);
280
    if (ret == -1) {
281
        error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
282
    } else {
283
        seek_data = g_malloc0(sizeof(GuestFileRead));
284
        seek_data->position = ftell(fh);
285
        seek_data->eof = feof(fh);
286
    }
287
    clearerr(fh);
288

    
289
    return seek_data;
290
}
291

    
292
void qmp_guest_file_flush(int64_t handle, Error **err)
293
{
294
    GuestFileHandle *gfh = guest_file_handle_find(handle);
295
    FILE *fh;
296
    int ret;
297

    
298
    if (!gfh) {
299
        error_set(err, QERR_FD_NOT_FOUND, "handle");
300
        return;
301
    }
302

    
303
    fh = gfh->fh;
304
    ret = fflush(fh);
305
    if (ret == EOF) {
306
        error_set(err, QERR_QGA_COMMAND_FAILED, strerror(errno));
307
    }
308
}
309

    
310
static void guest_file_init(void)
311
{
312
    QTAILQ_INIT(&guest_file_state.filehandles);
313
}
314

    
315
/* linux-specific implementations. avoid this if at all possible. */
316
#if defined(__linux__)
317

    
318
#if defined(CONFIG_FSFREEZE) || defined(CONFIG_FSTRIM)
319
typedef struct FsMount {
320
    char *dirname;
321
    char *devtype;
322
    QTAILQ_ENTRY(FsMount) next;
323
} FsMount;
324

    
325
typedef QTAILQ_HEAD(, FsMount) FsMountList;
326

    
327
static void free_fs_mount_list(FsMountList *mounts)
328
{
329
     FsMount *mount, *temp;
330

    
331
     if (!mounts) {
332
         return;
333
     }
334

    
335
     QTAILQ_FOREACH_SAFE(mount, mounts, next, temp) {
336
         QTAILQ_REMOVE(mounts, mount, next);
337
         g_free(mount->dirname);
338
         g_free(mount->devtype);
339
         g_free(mount);
340
     }
341
}
342

    
343
/*
344
 * Walk the mount table and build a list of local file systems
345
 */
346
static int build_fs_mount_list(FsMountList *mounts)
347
{
348
    struct mntent *ment;
349
    FsMount *mount;
350
    char const *mtab = "/proc/self/mounts";
351
    FILE *fp;
352

    
353
    fp = setmntent(mtab, "r");
354
    if (!fp) {
355
        g_warning("fsfreeze: unable to read mtab");
356
        return -1;
357
    }
358

    
359
    while ((ment = getmntent(fp))) {
360
        /*
361
         * An entry which device name doesn't start with a '/' is
362
         * either a dummy file system or a network file system.
363
         * Add special handling for smbfs and cifs as is done by
364
         * coreutils as well.
365
         */
366
        if ((ment->mnt_fsname[0] != '/') ||
367
            (strcmp(ment->mnt_type, "smbfs") == 0) ||
368
            (strcmp(ment->mnt_type, "cifs") == 0)) {
369
            continue;
370
        }
371

    
372
        mount = g_malloc0(sizeof(FsMount));
373
        mount->dirname = g_strdup(ment->mnt_dir);
374
        mount->devtype = g_strdup(ment->mnt_type);
375

    
376
        QTAILQ_INSERT_TAIL(mounts, mount, next);
377
    }
378

    
379
    endmntent(fp);
380

    
381
    return 0;
382
}
383
#endif
384

    
385
#if defined(CONFIG_FSFREEZE)
386

    
387
/*
388
 * Return status of freeze/thaw
389
 */
390
GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
391
{
392
    if (ga_is_frozen(ga_state)) {
393
        return GUEST_FSFREEZE_STATUS_FROZEN;
394
    }
395

    
396
    return GUEST_FSFREEZE_STATUS_THAWED;
397
}
398

    
399
/*
400
 * Walk list of mounted file systems in the guest, and freeze the ones which
401
 * are real local file systems.
402
 */
403
int64_t qmp_guest_fsfreeze_freeze(Error **err)
404
{
405
    int ret = 0, i = 0;
406
    FsMountList mounts;
407
    struct FsMount *mount;
408
    int fd;
409
    char err_msg[512];
410

    
411
    slog("guest-fsfreeze called");
412

    
413
    QTAILQ_INIT(&mounts);
414
    ret = build_fs_mount_list(&mounts);
415
    if (ret < 0) {
416
        return ret;
417
    }
418

    
419
    /* cannot risk guest agent blocking itself on a write in this state */
420
    ga_set_frozen(ga_state);
421

    
422
    QTAILQ_FOREACH(mount, &mounts, next) {
423
        fd = qemu_open(mount->dirname, O_RDONLY);
424
        if (fd == -1) {
425
            sprintf(err_msg, "failed to open %s, %s", mount->dirname,
426
                    strerror(errno));
427
            error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
428
            goto error;
429
        }
430

    
431
        /* we try to cull filesytems we know won't work in advance, but other
432
         * filesytems may not implement fsfreeze for less obvious reasons.
433
         * these will report EOPNOTSUPP. we simply ignore these when tallying
434
         * the number of frozen filesystems.
435
         *
436
         * any other error means a failure to freeze a filesystem we
437
         * expect to be freezable, so return an error in those cases
438
         * and return system to thawed state.
439
         */
440
        ret = ioctl(fd, FIFREEZE);
441
        if (ret == -1) {
442
            if (errno != EOPNOTSUPP) {
443
                sprintf(err_msg, "failed to freeze %s, %s",
444
                        mount->dirname, strerror(errno));
445
                error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
446
                close(fd);
447
                goto error;
448
            }
449
        } else {
450
            i++;
451
        }
452
        close(fd);
453
    }
454

    
455
    free_fs_mount_list(&mounts);
456
    return i;
457

    
458
error:
459
    free_fs_mount_list(&mounts);
460
    qmp_guest_fsfreeze_thaw(NULL);
461
    return 0;
462
}
463

    
464
/*
465
 * Walk list of frozen file systems in the guest, and thaw them.
466
 */
467
int64_t qmp_guest_fsfreeze_thaw(Error **err)
468
{
469
    int ret;
470
    FsMountList mounts;
471
    FsMount *mount;
472
    int fd, i = 0, logged;
473

    
474
    QTAILQ_INIT(&mounts);
475
    ret = build_fs_mount_list(&mounts);
476
    if (ret) {
477
        error_set(err, QERR_QGA_COMMAND_FAILED,
478
                  "failed to enumerate filesystems");
479
        return 0;
480
    }
481

    
482
    QTAILQ_FOREACH(mount, &mounts, next) {
483
        logged = false;
484
        fd = qemu_open(mount->dirname, O_RDONLY);
485
        if (fd == -1) {
486
            continue;
487
        }
488
        /* we have no way of knowing whether a filesystem was actually unfrozen
489
         * as a result of a successful call to FITHAW, only that if an error
490
         * was returned the filesystem was *not* unfrozen by that particular
491
         * call.
492
         *
493
         * since multiple preceding FIFREEZEs require multiple calls to FITHAW
494
         * to unfreeze, continuing issuing FITHAW until an error is returned,
495
         * in which case either the filesystem is in an unfreezable state, or,
496
         * more likely, it was thawed previously (and remains so afterward).
497
         *
498
         * also, since the most recent successful call is the one that did
499
         * the actual unfreeze, we can use this to provide an accurate count
500
         * of the number of filesystems unfrozen by guest-fsfreeze-thaw, which
501
         * may * be useful for determining whether a filesystem was unfrozen
502
         * during the freeze/thaw phase by a process other than qemu-ga.
503
         */
504
        do {
505
            ret = ioctl(fd, FITHAW);
506
            if (ret == 0 && !logged) {
507
                i++;
508
                logged = true;
509
            }
510
        } while (ret == 0);
511
        close(fd);
512
    }
513

    
514
    ga_unset_frozen(ga_state);
515
    free_fs_mount_list(&mounts);
516
    return i;
517
}
518

    
519
static void guest_fsfreeze_cleanup(void)
520
{
521
    int64_t ret;
522
    Error *err = NULL;
523

    
524
    if (ga_is_frozen(ga_state) == GUEST_FSFREEZE_STATUS_FROZEN) {
525
        ret = qmp_guest_fsfreeze_thaw(&err);
526
        if (ret < 0 || err) {
527
            slog("failed to clean up frozen filesystems");
528
        }
529
    }
530
}
531
#endif /* CONFIG_FSFREEZE */
532

    
533
#if defined(CONFIG_FSTRIM)
534
/*
535
 * Walk list of mounted file systems in the guest, and trim them.
536
 */
537
void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
538
{
539
    int ret = 0;
540
    FsMountList mounts;
541
    struct FsMount *mount;
542
    int fd;
543
    char err_msg[512];
544
    struct fstrim_range r = {
545
        .start = 0,
546
        .len = -1,
547
        .minlen = has_minimum ? minimum : 0,
548
    };
549

    
550
    slog("guest-fstrim called");
551

    
552
    QTAILQ_INIT(&mounts);
553
    ret = build_fs_mount_list(&mounts);
554
    if (ret < 0) {
555
        return;
556
    }
557

    
558
    QTAILQ_FOREACH(mount, &mounts, next) {
559
        fd = qemu_open(mount->dirname, O_RDONLY);
560
        if (fd == -1) {
561
            sprintf(err_msg, "failed to open %s, %s", mount->dirname,
562
                    strerror(errno));
563
            error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
564
            goto error;
565
        }
566

    
567
        /* We try to cull filesytems we know won't work in advance, but other
568
         * filesytems may not implement fstrim for less obvious reasons.  These
569
         * will report EOPNOTSUPP; we simply ignore these errors.  Any other
570
         * error means an unexpected error, so return it in those cases.  In
571
         * some other cases ENOTTY will be reported (e.g. CD-ROMs).
572
         */
573
        ret = ioctl(fd, FITRIM, &r);
574
        if (ret == -1) {
575
            if (errno != ENOTTY && errno != EOPNOTSUPP) {
576
                sprintf(err_msg, "failed to trim %s, %s",
577
                        mount->dirname, strerror(errno));
578
                error_set(err, QERR_QGA_COMMAND_FAILED, err_msg);
579
                close(fd);
580
                goto error;
581
            }
582
        }
583
        close(fd);
584
    }
585

    
586
error:
587
    free_fs_mount_list(&mounts);
588
}
589
#endif /* CONFIG_FSTRIM */
590

    
591

    
592
#define LINUX_SYS_STATE_FILE "/sys/power/state"
593
#define SUSPEND_SUPPORTED 0
594
#define SUSPEND_NOT_SUPPORTED 1
595

    
596
static void bios_supports_mode(const char *pmutils_bin, const char *pmutils_arg,
597
                               const char *sysfile_str, Error **err)
598
{
599
    char *pmutils_path;
600
    pid_t pid, rpid;
601
    int status;
602

    
603
    pmutils_path = g_find_program_in_path(pmutils_bin);
604

    
605
    pid = fork();
606
    if (!pid) {
607
        char buf[32]; /* hopefully big enough */
608
        ssize_t ret;
609
        int fd;
610

    
611
        setsid();
612
        reopen_fd_to_null(0);
613
        reopen_fd_to_null(1);
614
        reopen_fd_to_null(2);
615

    
616
        if (pmutils_path) {
617
            execle(pmutils_path, pmutils_bin, pmutils_arg, NULL, environ);
618
        }
619

    
620
        /*
621
         * If we get here either pm-utils is not installed or execle() has
622
         * failed. Let's try the manual method if the caller wants it.
623
         */
624

    
625
        if (!sysfile_str) {
626
            _exit(SUSPEND_NOT_SUPPORTED);
627
        }
628

    
629
        fd = open(LINUX_SYS_STATE_FILE, O_RDONLY);
630
        if (fd < 0) {
631
            _exit(SUSPEND_NOT_SUPPORTED);
632
        }
633

    
634
        ret = read(fd, buf, sizeof(buf)-1);
635
        if (ret <= 0) {
636
            _exit(SUSPEND_NOT_SUPPORTED);
637
        }
638
        buf[ret] = '\0';
639

    
640
        if (strstr(buf, sysfile_str)) {
641
            _exit(SUSPEND_SUPPORTED);
642
        }
643

    
644
        _exit(SUSPEND_NOT_SUPPORTED);
645
    }
646

    
647
    g_free(pmutils_path);
648

    
649
    if (pid < 0) {
650
        goto undef_err;
651
    }
652

    
653
    do {
654
        rpid = waitpid(pid, &status, 0);
655
    } while (rpid == -1 && errno == EINTR);
656
    if (rpid == pid && WIFEXITED(status)) {
657
        switch (WEXITSTATUS(status)) {
658
        case SUSPEND_SUPPORTED:
659
            return;
660
        case SUSPEND_NOT_SUPPORTED:
661
            error_set(err, QERR_UNSUPPORTED);
662
            return;
663
        default:
664
            goto undef_err;
665
        }
666
    }
667

    
668
undef_err:
669
    error_set(err, QERR_UNDEFINED_ERROR);
670
}
671

    
672
static void guest_suspend(const char *pmutils_bin, const char *sysfile_str,
673
                          Error **err)
674
{
675
    char *pmutils_path;
676
    pid_t rpid, pid;
677
    int status;
678

    
679
    pmutils_path = g_find_program_in_path(pmutils_bin);
680

    
681
    pid = fork();
682
    if (pid == 0) {
683
        /* child */
684
        int fd;
685

    
686
        setsid();
687
        reopen_fd_to_null(0);
688
        reopen_fd_to_null(1);
689
        reopen_fd_to_null(2);
690

    
691
        if (pmutils_path) {
692
            execle(pmutils_path, pmutils_bin, NULL, environ);
693
        }
694

    
695
        /*
696
         * If we get here either pm-utils is not installed or execle() has
697
         * failed. Let's try the manual method if the caller wants it.
698
         */
699

    
700
        if (!sysfile_str) {
701
            _exit(EXIT_FAILURE);
702
        }
703

    
704
        fd = open(LINUX_SYS_STATE_FILE, O_WRONLY);
705
        if (fd < 0) {
706
            _exit(EXIT_FAILURE);
707
        }
708

    
709
        if (write(fd, sysfile_str, strlen(sysfile_str)) < 0) {
710
            _exit(EXIT_FAILURE);
711
        }
712

    
713
        _exit(EXIT_SUCCESS);
714
    }
715

    
716
    g_free(pmutils_path);
717

    
718
    if (pid < 0) {
719
        goto exit_err;
720
    }
721

    
722
    do {
723
        rpid = waitpid(pid, &status, 0);
724
    } while (rpid == -1 && errno == EINTR);
725
    if (rpid == pid && WIFEXITED(status) && !WEXITSTATUS(status)) {
726
        return;
727
    }
728

    
729
exit_err:
730
    error_set(err, QERR_UNDEFINED_ERROR);
731
}
732

    
733
void qmp_guest_suspend_disk(Error **err)
734
{
735
    bios_supports_mode("pm-is-supported", "--hibernate", "disk", err);
736
    if (error_is_set(err)) {
737
        return;
738
    }
739

    
740
    guest_suspend("pm-hibernate", "disk", err);
741
}
742

    
743
void qmp_guest_suspend_ram(Error **err)
744
{
745
    bios_supports_mode("pm-is-supported", "--suspend", "mem", err);
746
    if (error_is_set(err)) {
747
        return;
748
    }
749

    
750
    guest_suspend("pm-suspend", "mem", err);
751
}
752

    
753
void qmp_guest_suspend_hybrid(Error **err)
754
{
755
    bios_supports_mode("pm-is-supported", "--suspend-hybrid", NULL, err);
756
    if (error_is_set(err)) {
757
        return;
758
    }
759

    
760
    guest_suspend("pm-suspend-hybrid", NULL, err);
761
}
762

    
763
static GuestNetworkInterfaceList *
764
guest_find_interface(GuestNetworkInterfaceList *head,
765
                     const char *name)
766
{
767
    for (; head; head = head->next) {
768
        if (strcmp(head->value->name, name) == 0) {
769
            break;
770
        }
771
    }
772

    
773
    return head;
774
}
775

    
776
/*
777
 * Build information about guest interfaces
778
 */
779
GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
780
{
781
    GuestNetworkInterfaceList *head = NULL, *cur_item = NULL;
782
    struct ifaddrs *ifap, *ifa;
783
    char err_msg[512];
784

    
785
    if (getifaddrs(&ifap) < 0) {
786
        snprintf(err_msg, sizeof(err_msg),
787
                 "getifaddrs failed: %s", strerror(errno));
788
        error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
789
        goto error;
790
    }
791

    
792
    for (ifa = ifap; ifa; ifa = ifa->ifa_next) {
793
        GuestNetworkInterfaceList *info;
794
        GuestIpAddressList **address_list = NULL, *address_item = NULL;
795
        char addr4[INET_ADDRSTRLEN];
796
        char addr6[INET6_ADDRSTRLEN];
797
        int sock;
798
        struct ifreq ifr;
799
        unsigned char *mac_addr;
800
        void *p;
801

    
802
        g_debug("Processing %s interface", ifa->ifa_name);
803

    
804
        info = guest_find_interface(head, ifa->ifa_name);
805

    
806
        if (!info) {
807
            info = g_malloc0(sizeof(*info));
808
            info->value = g_malloc0(sizeof(*info->value));
809
            info->value->name = g_strdup(ifa->ifa_name);
810

    
811
            if (!cur_item) {
812
                head = cur_item = info;
813
            } else {
814
                cur_item->next = info;
815
                cur_item = info;
816
            }
817
        }
818

    
819
        if (!info->value->has_hardware_address &&
820
            ifa->ifa_flags & SIOCGIFHWADDR) {
821
            /* we haven't obtained HW address yet */
822
            sock = socket(PF_INET, SOCK_STREAM, 0);
823
            if (sock == -1) {
824
                snprintf(err_msg, sizeof(err_msg),
825
                         "failed to create socket: %s", strerror(errno));
826
                error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
827
                goto error;
828
            }
829

    
830
            memset(&ifr, 0, sizeof(ifr));
831
            pstrcpy(ifr.ifr_name, IF_NAMESIZE, info->value->name);
832
            if (ioctl(sock, SIOCGIFHWADDR, &ifr) == -1) {
833
                snprintf(err_msg, sizeof(err_msg),
834
                         "failed to get MAC address of %s: %s",
835
                         ifa->ifa_name,
836
                         strerror(errno));
837
                error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
838
                goto error;
839
            }
840

    
841
            mac_addr = (unsigned char *) &ifr.ifr_hwaddr.sa_data;
842

    
843
            if (asprintf(&info->value->hardware_address,
844
                         "%02x:%02x:%02x:%02x:%02x:%02x",
845
                         (int) mac_addr[0], (int) mac_addr[1],
846
                         (int) mac_addr[2], (int) mac_addr[3],
847
                         (int) mac_addr[4], (int) mac_addr[5]) == -1) {
848
                snprintf(err_msg, sizeof(err_msg),
849
                         "failed to format MAC: %s", strerror(errno));
850
                error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
851
                goto error;
852
            }
853

    
854
            info->value->has_hardware_address = true;
855
            close(sock);
856
        }
857

    
858
        if (ifa->ifa_addr &&
859
            ifa->ifa_addr->sa_family == AF_INET) {
860
            /* interface with IPv4 address */
861
            address_item = g_malloc0(sizeof(*address_item));
862
            address_item->value = g_malloc0(sizeof(*address_item->value));
863
            p = &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr;
864
            if (!inet_ntop(AF_INET, p, addr4, sizeof(addr4))) {
865
                snprintf(err_msg, sizeof(err_msg),
866
                         "inet_ntop failed : %s", strerror(errno));
867
                error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
868
                goto error;
869
            }
870

    
871
            address_item->value->ip_address = g_strdup(addr4);
872
            address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV4;
873

    
874
            if (ifa->ifa_netmask) {
875
                /* Count the number of set bits in netmask.
876
                 * This is safe as '1' and '0' cannot be shuffled in netmask. */
877
                p = &((struct sockaddr_in *)ifa->ifa_netmask)->sin_addr;
878
                address_item->value->prefix = ctpop32(((uint32_t *) p)[0]);
879
            }
880
        } else if (ifa->ifa_addr &&
881
                   ifa->ifa_addr->sa_family == AF_INET6) {
882
            /* interface with IPv6 address */
883
            address_item = g_malloc0(sizeof(*address_item));
884
            address_item->value = g_malloc0(sizeof(*address_item->value));
885
            p = &((struct sockaddr_in6 *)ifa->ifa_addr)->sin6_addr;
886
            if (!inet_ntop(AF_INET6, p, addr6, sizeof(addr6))) {
887
                snprintf(err_msg, sizeof(err_msg),
888
                         "inet_ntop failed : %s", strerror(errno));
889
                error_set(errp, QERR_QGA_COMMAND_FAILED, err_msg);
890
                goto error;
891
            }
892

    
893
            address_item->value->ip_address = g_strdup(addr6);
894
            address_item->value->ip_address_type = GUEST_IP_ADDRESS_TYPE_IPV6;
895

    
896
            if (ifa->ifa_netmask) {
897
                /* Count the number of set bits in netmask.
898
                 * This is safe as '1' and '0' cannot be shuffled in netmask. */
899
                p = &((struct sockaddr_in6 *)ifa->ifa_netmask)->sin6_addr;
900
                address_item->value->prefix =
901
                    ctpop32(((uint32_t *) p)[0]) +
902
                    ctpop32(((uint32_t *) p)[1]) +
903
                    ctpop32(((uint32_t *) p)[2]) +
904
                    ctpop32(((uint32_t *) p)[3]);
905
            }
906
        }
907

    
908
        if (!address_item) {
909
            continue;
910
        }
911

    
912
        address_list = &info->value->ip_addresses;
913

    
914
        while (*address_list && (*address_list)->next) {
915
            address_list = &(*address_list)->next;
916
        }
917

    
918
        if (!*address_list) {
919
            *address_list = address_item;
920
        } else {
921
            (*address_list)->next = address_item;
922
        }
923

    
924
        info->value->has_ip_addresses = true;
925

    
926

    
927
    }
928

    
929
    freeifaddrs(ifap);
930
    return head;
931

    
932
error:
933
    freeifaddrs(ifap);
934
    qapi_free_GuestNetworkInterfaceList(head);
935
    return NULL;
936
}
937

    
938
#else /* defined(__linux__) */
939

    
940
void qmp_guest_suspend_disk(Error **err)
941
{
942
    error_set(err, QERR_UNSUPPORTED);
943
}
944

    
945
void qmp_guest_suspend_ram(Error **err)
946
{
947
    error_set(err, QERR_UNSUPPORTED);
948
}
949

    
950
void qmp_guest_suspend_hybrid(Error **err)
951
{
952
    error_set(err, QERR_UNSUPPORTED);
953
}
954

    
955
GuestNetworkInterfaceList *qmp_guest_network_get_interfaces(Error **errp)
956
{
957
    error_set(errp, QERR_UNSUPPORTED);
958
    return NULL;
959
}
960

    
961
#endif
962

    
963
#if !defined(CONFIG_FSFREEZE)
964

    
965
GuestFsfreezeStatus qmp_guest_fsfreeze_status(Error **err)
966
{
967
    error_set(err, QERR_UNSUPPORTED);
968

    
969
    return 0;
970
}
971

    
972
int64_t qmp_guest_fsfreeze_freeze(Error **err)
973
{
974
    error_set(err, QERR_UNSUPPORTED);
975

    
976
    return 0;
977
}
978

    
979
int64_t qmp_guest_fsfreeze_thaw(Error **err)
980
{
981
    error_set(err, QERR_UNSUPPORTED);
982

    
983
    return 0;
984
}
985
#endif /* CONFIG_FSFREEZE */
986

    
987
#if !defined(CONFIG_FSTRIM)
988
void qmp_guest_fstrim(bool has_minimum, int64_t minimum, Error **err)
989
{
990
    error_set(err, QERR_UNSUPPORTED);
991

    
992
    return;
993
}
994
#endif
995

    
996
/* register init/cleanup routines for stateful command groups */
997
void ga_command_state_init(GAState *s, GACommandState *cs)
998
{
999
#if defined(CONFIG_FSFREEZE)
1000
    ga_command_state_add(cs, NULL, guest_fsfreeze_cleanup);
1001
#endif
1002
    ga_command_state_add(cs, guest_file_init, NULL);
1003
}