Archipelago » qemu

/*

 * QEMU disk image utility

 * Copyright (c) 2003-2007 Fabrice Bellard

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to deal

 * in the Software without restriction, including without limitation the rights

    term_printf(filename);

}

{

    va_list ap;

    va_start(ap, fmt);

    tty.c_cflag |= CS8;

    tty.c_cc[VMIN] = 1;

    tty.c_cc[VTIME] = 0;

    tcsetattr (0, TCSANOW, &tty);

    atexit(term_exit);

    int64_t size;

    const char *p;

    BlockDriver *drv;

    encrypted = 0;

    for(;;) {

        c = getopt(argc, argv, "b:f:he");

            break;

        }

    }

        help();

    filename = argv[optind++];

    size = 0;

            break;

        }

    }

        help();

    filename = argv[optind++];

            break;

        }

    }

        help();

    filename = argv[optind++];

        help();

    out_filename = argv[optind++];

    bs = bdrv_new_open(filename, fmt);

    drv = bdrv_find_format(out_fmt);

            error("Error while formatting '%s'", out_filename);

        }

    }

    out_bs = bdrv_new_open(out_filename, out_fmt);

    if (compress) {

                n = cluster_sectors;

            else

                n = nb_sectors;

                error("error while reading");

            if (n < cluster_sectors)

                memset(buf + n * 512, 0, cluster_size - n * 512);

            if (is_not_zero(buf, cluster_size)) {

                                          cluster_sectors) != 0)

                    error("error while compressing sector %" PRId64,

                          sector_num);

                n = (IO_BUF_SIZE / 512);

            else

                n = nb_sectors;

                error("error while reading");

            /* NOTE: at the same time we convert, we do not write zero

               sectors to have a chance to compress the image. Ideally, we

            buf1 = buf;

            while (n > 0) {

                if (is_allocated_sectors(buf1, n, &n1)) {

                        error("error while writing");

                }

                sector_num += n1;

	    return (((int64_t) high) << 32) + low;

    }

        return -1;

    return st.st_size;

}

static int64_t get_allocated_file_size(const char *filename)

{

    struct stat st;

        return -1;

    return (int64_t)st.st_blocks * 512;

}

            break;

        }

    }

        help();

    filename = argv[optind++];

    if (allocated_size < 0)

	sprintf(dsize_buf, "unavailable");

    else

                                allocated_size);

    printf("image: %s\n"

           "file format: %s\n"

           "virtual size: %s (%" PRId64 " bytes)\n"

           "disk size: %s\n",

           (total_sectors * 512),

           dsize_buf);

    if (bdrv_is_encrypted(bs))

        printf("encrypted: yes\n");

    if (bdrv_get_info(bs, &bdi) >= 0) {

            printf("cluster_size: %d\n", bdi.cluster_size);

    }

    bdrv_get_backing_filename(bs, backing_filename, sizeof(backing_filename));

    if (backing_filename[0] != '\0') {

        path_combine(backing_filename2, sizeof(backing_filename2),

                     filename, backing_filename);

               backing_filename,

               backing_filename2);

    }