static int raw_create(const char *filename, QemuOpts *opts, Error **errp)

{

    int fd;

    int result = 0;

    int64_t total_size = 0;

    bool nocow = false;

    PreallocMode prealloc;

    char *buf = NULL;

    Error *local_err = NULL;



    strstart(filename, "file:", &filename);



    /* Read out options */

    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

                          BDRV_SECTOR_SIZE);

    nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);

    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

    prealloc = qapi_enum_parse(PreallocMode_lookup, buf,

                               PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,

                               &local_err);

    g_free(buf);

    if (local_err) {

        error_propagate(errp, local_err);

        result = -EINVAL;

        goto out;

    }



    fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,

                   0644);

    if (fd < 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not create file");

        goto out;

    }



    if (nocow) {

#ifdef __linux__

        /* Set NOCOW flag to solve performance issue on fs like btrfs.

         * This is an optimisation. The FS_IOC_SETFLAGS ioctl return value

         * will be ignored since any failure of this operation should not

         * block the left work.

         */

        int attr;

        if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {

            attr |= FS_NOCOW_FL;

            ioctl(fd, FS_IOC_SETFLAGS, &attr);

        }

#endif

    }



    if (ftruncate(fd, total_size) != 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not resize file");

        goto out_close;

    }



    switch (prealloc) {

#ifdef CONFIG_POSIX_FALLOCATE

    case PREALLOC_MODE_FALLOC:

        /* posix_fallocate() doesn't set errno. */

        result = -posix_fallocate(fd, 0, total_size);

        if (result != 0) {

            error_setg_errno(errp, -result,

                             "Could not preallocate data for the new file");

        }

        break;

#endif

    case PREALLOC_MODE_FULL:

    {

        int64_t num = 0, left = total_size;

        buf = g_malloc0(65536);



        while (left > 0) {

            num = MIN(left, 65536);

            result = write(fd, buf, num);

            if (result < 0) {

                result = -errno;

                error_setg_errno(errp, -result,

                                 "Could not write to the new file");

                break;

            }

            left -= result;

        }

        fsync(fd);

        g_free(buf);

        break;

    }

    case PREALLOC_MODE_OFF:

        break;

    default:

        result = -EINVAL;

        error_setg(errp, "Unsupported preallocation mode: %s",

                   PreallocMode_lookup[prealloc]);

        break;

    }



out_close:

    if (qemu_close(fd) != 0 && result == 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not close the new file");

    }

out:

    return result;

}

static int raw_create(const char *filename, QemuOpts *opts, Error **errp)

{

    int fd;

    int result = 0;

    int64_t total_size = 0;

    bool nocow = false;

    PreallocMode prealloc;

    char *buf = NULL;

    Error *local_err = NULL;



    strstart(filename, "file:", &filename);



    

    total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),

                          BDRV_SECTOR_SIZE);

    nocow = qemu_opt_get_bool(opts, BLOCK_OPT_NOCOW, false);

    buf = qemu_opt_get_del(opts, BLOCK_OPT_PREALLOC);

    prealloc = qapi_enum_parse(PreallocMode_lookup, buf,

                               PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,

                               &local_err);

    g_free(buf);

    if (local_err) {

        error_propagate(errp, local_err);

        result = -EINVAL;

        goto out;

    }



    fd = qemu_open(filename, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,

                   0644);

    if (fd < 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not create file");

        goto out;

    }



    if (nocow) {

#ifdef __linux__

        









        int attr;

        if (ioctl(fd, FS_IOC_GETFLAGS, &attr) == 0) {

            attr |= FS_NOCOW_FL;

            ioctl(fd, FS_IOC_SETFLAGS, &attr);

        }

#endif

    }



    if (ftruncate(fd, total_size) != 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not resize file");

        goto out_close;

    }



    switch (prealloc) {

#ifdef CONFIG_POSIX_FALLOCATE

    case PREALLOC_MODE_FALLOC:

        

        result = -posix_fallocate(fd, 0, total_size);

        if (result != 0) {

            error_setg_errno(errp, -result,

                             "Could not preallocate data for the new file");

        }

        break;

#endif

    case PREALLOC_MODE_FULL:

    {

        int64_t num = 0, left = total_size;

        buf = g_malloc0(65536);



        while (left > 0) {

            num = MIN(left, 65536);

            result = write(fd, buf, num);

            if (result < 0) {

                result = -errno;

                error_setg_errno(errp, -result,

                                 "Could not write to the new file");

                break;

            }

            left -= result;

        }

        fsync(fd);

        g_free(buf);

        break;

    }

    case PREALLOC_MODE_OFF:

        break;

    default:

        result = -EINVAL;

        error_setg(errp, "Unsupported preallocation mode: %s",

                   PreallocMode_lookup[prealloc]);

        break;

    }



out_close:

    if (qemu_close(fd) != 0 && result == 0) {

        result = -errno;

        error_setg_errno(errp, -result, "Could not close the new file");

    }

out:

    return result;

}

static int FUNC_0(const char *VAR_0, QemuOpts *VAR_1, Error **VAR_2)

{

    int VAR_3;

    int VAR_4 = 0;

    int64_t total_size = 0;

    bool nocow = false;

    PreallocMode prealloc;

    char *VAR_5 = NULL;

    Error *local_err = NULL;



    strstart(VAR_0, "file:", &VAR_0);



    

    total_size = ROUND_UP(qemu_opt_get_size_del(VAR_1, BLOCK_OPT_SIZE, 0),

                          BDRV_SECTOR_SIZE);

    nocow = qemu_opt_get_bool(VAR_1, BLOCK_OPT_NOCOW, false);

    VAR_5 = qemu_opt_get_del(VAR_1, BLOCK_OPT_PREALLOC);

    prealloc = qapi_enum_parse(PreallocMode_lookup, VAR_5,

                               PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,

                               &local_err);

    g_free(VAR_5);

    if (local_err) {

        error_propagate(VAR_2, local_err);

        VAR_4 = -EINVAL;

        goto out;

    }



    VAR_3 = qemu_open(VAR_0, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,

                   0644);

    if (VAR_3 < 0) {

        VAR_4 = -errno;

        error_setg_errno(VAR_2, -VAR_4, "Could not create file");

        goto out;

    }



    if (nocow) {

#ifdef __linux__

        









        int attr;

        if (ioctl(VAR_3, FS_IOC_GETFLAGS, &attr) == 0) {

            attr |= FS_NOCOW_FL;

            ioctl(VAR_3, FS_IOC_SETFLAGS, &attr);

        }

#endif

    }



    if (ftruncate(VAR_3, total_size) != 0) {

        VAR_4 = -errno;

        error_setg_errno(VAR_2, -VAR_4, "Could not resize file");

        goto out_close;

    }



    switch (prealloc) {

#ifdef CONFIG_POSIX_FALLOCATE

    case PREALLOC_MODE_FALLOC:

        

        VAR_4 = -posix_fallocate(VAR_3, 0, total_size);

        if (VAR_4 != 0) {

            error_setg_errno(VAR_2, -VAR_4,

                             "Could not preallocate data for the new file");

        }

        break;

#endif

    case PREALLOC_MODE_FULL:

    {

        int64_t num = 0, left = total_size;

        VAR_5 = g_malloc0(65536);



        while (left > 0) {

            num = MIN(left, 65536);

            VAR_4 = write(VAR_3, VAR_5, num);

            if (VAR_4 < 0) {

                VAR_4 = -errno;

                error_setg_errno(VAR_2, -VAR_4,

                                 "Could not write to the new file");

                break;

            }

            left -= VAR_4;

        }

        fsync(VAR_3);

        g_free(VAR_5);

        break;

    }

    case PREALLOC_MODE_OFF:

        break;

    default:

        VAR_4 = -EINVAL;

        error_setg(VAR_2, "Unsupported preallocation mode: %s",

                   PreallocMode_lookup[prealloc]);

        break;

    }



out_close:

    if (qemu_close(VAR_3) != 0 && VAR_4 == 0) {

        VAR_4 = -errno;

        error_setg_errno(VAR_2, -VAR_4, "Could not close the new file");

    }

out:

    return VAR_4;

}

static int FUNC_0(const char *VAR_0, QemuOpts *VAR_1, Error **VAR_2)
{ int VAR_3; int VAR_4 = 0; int64_t total_size = 0; bool nocow = false; PreallocMode prealloc; char *VAR_5 = NULL; Error *local_err = NULL; strstart(VAR_0, "file:", &VAR_0); total_size = ROUND_UP(qemu_opt_get_size_del(VAR_1, BLOCK_OPT_SIZE, 0),
BDRV_SECTOR_SIZE); nocow = qemu_opt_get_bool(VAR_1, BLOCK_OPT_NOCOW, false); VAR_5 = qemu_opt_get_del(VAR_1, BLOCK_OPT_PREALLOC); prealloc = qapi_enum_parse(PreallocMode_lookup, VAR_5,
PREALLOC_MODE_MAX, PREALLOC_MODE_OFF,
&local_err); g_free(VAR_5); if (local_err) { error_propagate(VAR_2, local_err); VAR_4 = -EINVAL; goto out; } VAR_3 = qemu_open(VAR_0, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,
0644); if (VAR_3 < 0) { VAR_4 = -errno; error_setg_errno(VAR_2, -VAR_4, "Could not create file"); goto out; } if (nocow) { #ifdef __linux__
int attr; if (ioctl(VAR_3, FS_IOC_GETFLAGS, &attr) == 0) { attr |= FS_NOCOW_FL; ioctl(VAR_3, FS_IOC_SETFLAGS, &attr); } #endif
} if (ftruncate(VAR_3, total_size) != 0) { VAR_4 = -errno; error_setg_errno(VAR_2, -VAR_4, "Could not resize file"); goto out_close; } switch (prealloc) { #ifdef CONFIG_POSIX_FALLOCATE
case PREALLOC_MODE_FALLOC:
VAR_4 = -posix_fallocate(VAR_3, 0, total_size); if (VAR_4 != 0) { error_setg_errno(VAR_2, -VAR_4,
"Could not preallocate data for the new file"); } break; #endif
case PREALLOC_MODE_FULL:
{ int64_t num = 0, left = total_size; VAR_5 = g_malloc0(65536); while (left > 0) { num = MIN(left, 65536); VAR_4 = write(VAR_3, VAR_5, num); if (VAR_4 < 0) { VAR_4 = -errno; error_setg_errno(VAR_2, -VAR_4,
"Could not write to the new file"); break; } left -= VAR_4; } fsync(VAR_3); g_free(VAR_5); break; } case PREALLOC_MODE_OFF:
break; default:
VAR_4 = -EINVAL; error_setg(VAR_2, "Unsupported preallocation mode: %s",
PreallocMode_lookup[prealloc]); break; } out_close:
if (qemu_close(VAR_3) != 0 && VAR_4 == 0) { VAR_4 = -errno; error_setg_errno(VAR_2, -VAR_4, "Could not close the new file"); } out:
return VAR_4; }