/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright (c) 2014 by Delphix. All rights reserved.
 */

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <umem.h>
#include <stddef.h>
#include <string.h>
#include <sys/types.h>
#include <sys/errno.h>
#include <sys/list.h>

extern int errno;

typedef enum {
        SEG_HOLE,
        SEG_DATA,
        SEG_TYPES
} seg_type_t;

typedef struct segment {
        list_node_t     seg_node;
        seg_type_t      seg_type;
        off_t           seg_offset;
        off_t           seg_len;
} seg_t;

static int
no_memory(void) {
        (void) fprintf(stderr, "malloc failed\n");
        return (UMEM_CALLBACK_EXIT(255));
}

static void
usage(char *msg, int exit_value)
{
        (void) fprintf(stderr, "mkholes [-d|h offset:length] ... filename\n");
        (void) fprintf(stderr, "%s\n", msg);
        exit(exit_value);
}

static char *
get_random_buffer(size_t len)
{
        int     rand_fd;
        char    *buf;

        buf = umem_alloc(len, UMEM_NOFAIL);

        /*
         * Fill the buffer from /dev/urandom to counteract the
         * effects of compression.
         */
        if ((rand_fd = open("/dev/urandom", O_RDONLY)) < 0) {
                perror("open /dev/urandom failed");
                exit(1);
        }

        if (read(rand_fd, buf, len) < 0) {
                perror("read /dev/urandom failed");
                exit(1);
        }

        (void) close(rand_fd);

        return (buf);
}

static void
push_segment(list_t *seg_list, seg_type_t seg_type, char *optarg)
{
        char            *off_str, *len_str;
        static off_t    file_size = 0;
        off_t           off, len;
        seg_t           *seg;

        off_str = strtok(optarg, ":");
        len_str = strtok(NULL, ":");

        if (off_str == NULL || len_str == NULL)
                usage("Bad offset or length", 1);

        off = strtoull(off_str, NULL, 0);
        len = strtoull(len_str, NULL, 0);

        if (file_size >= off + len)
                usage("Ranges must ascend and may not overlap.", 1);
        file_size = off + len;

        seg = umem_alloc(sizeof (seg_t), UMEM_NOFAIL);
        seg->seg_type = seg_type;
        seg->seg_offset = off;
        seg->seg_len = len;

        list_insert_tail(seg_list, seg);
}

int
main(int argc, char *argv[])
{
        int     c, fd;
        char    *fname;
        list_t  seg_list;
        seg_t   *seg;

        umem_nofail_callback(no_memory);
        list_create(&seg_list, sizeof (seg_t), offsetof(seg_t, seg_node));

        while ((c = getopt(argc, argv, "d:h:")) != -1) {
                switch (c) {
                case 'd':
                        push_segment(&seg_list, SEG_DATA, optarg);
                        break;
                case 'h':
                        push_segment(&seg_list, SEG_HOLE, optarg);
                        break;
                }
        }
        argc -= optind;
        argv += optind;

        if ((fname = argv[0]) == NULL)
                usage("No filename specified", 1);
        fname = argv[0];

        if ((fd = open(fname, O_LARGEFILE | O_RDWR | O_CREAT | O_SYNC,
            00666)) < 0) {
                perror("open failed");
                exit(1);
        }

        while ((seg = list_remove_head(&seg_list)) != NULL) {
                char    *buf, *vbuf;
                off_t   off = seg->seg_offset;
                off_t   len = seg->seg_len;

                if (seg->seg_type == SEG_HOLE) {
                        struct flock    fl;
                        off_t bytes_read = 0;
                        ssize_t readlen = 1024 * 1024 * 16;

                        fl.l_whence = SEEK_SET;
                        fl.l_start = off;
                        fl.l_len = len;
                        if (fcntl(fd, F_FREESP, &fl) != 0) {
                                perror("freesp failed");
                                exit(1);
                        }

                        buf = (char *)umem_alloc(readlen, UMEM_NOFAIL);
                        vbuf = (char *)umem_zalloc(readlen, UMEM_NOFAIL);
                        while (bytes_read < len) {
                                ssize_t bytes = pread(fd, buf, readlen, off);
                                if (bytes < 0) {
                                        perror("pread hole failed");
                                        exit(1);
                                }

                                if (memcmp(buf, vbuf, bytes) != 0) {
                                        (void) fprintf(stderr, "Read back hole "
                                            "didn't match.\n");
                                        exit(1);
                                }
                                bytes_read += bytes;
                                off += bytes;
                        }

                        umem_free(buf, readlen);
                        umem_free(vbuf, readlen);
                        umem_free(seg, sizeof (seg_t));
                } else if (seg->seg_type == SEG_DATA) {
                        buf = get_random_buffer(len);
                        vbuf = (char *)umem_alloc(len, UMEM_NOFAIL);
                        if ((pwrite(fd, buf, len, off)) < 0) {
                                perror("pwrite failed");
                                exit(1);
                        }

                        if ((pread(fd, vbuf, len, off)) != len) {
                                perror("pread failed");
                                exit(1);
                        }

                        if (memcmp(buf, vbuf, len) != 0) {
                                (void) fprintf(stderr, "Read back buf didn't "
                                    "match.\n");
                                exit(1);
                        }

                        umem_free(buf, len);
                        umem_free(vbuf, len);
                        umem_free(seg, sizeof (seg_t));
                }
        }

        (void) close(fd);
        return (0);
}