/* 

 * makedumpfile.c

 * 

 * This code is for reading a dumpfile ganarated by makedumpfile command.

 *

 * Copyright (C) 2011  NEC Soft, Ltd.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2 of the License, or

 * (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * Author: Ken'ichi Ohmichi <oomichi mxs nes nec co jp>

 */

#define _LARGEFILE64_SOURCE 1  /* stat64() */

#include "defs.h"

#include "makedumpfile.h"

#include <byteswap.h>

static void flattened_format_get_osrelease(char *);

int flattened_format = 0;

struct flat_data {

	int64_t off_flattened;

	int64_t off_rearranged; /* offset which will be rearranged. */

	int64_t buf_size;

};

struct all_flat_data {

	unsigned long long	num_array;

	struct flat_data	*array;

	size_t			file_size;

};

struct all_flat_data afd;

struct makedumpfile_header fh_save;

static int

is_bigendian(void)

{

	int i = 0x12345678;

	if (*(char *)&i == 0x12)

		return TRUE;

	else

		return FALSE;

}

static unsigned long long

store_flat_data_array(char *file, struct flat_data **fda)

{

	int			result = FALSE, fd;

	int64_t			offset_fdh;

	int64_t			offset_report = 0;

	unsigned long long	num_allocated = 0;

	unsigned long long	num_stored    = 0;

	unsigned long long	sort_idx;

	unsigned long long	size_allocated;

	struct flat_data	*ptr = NULL, *cur, *new;

	struct makedumpfile_data_header	fdh;

	struct stat64		stat;

	ulonglong		pct, last_pct;

	char			buf[BUFSIZE];

	ssize_t			bytes_read;

	fd = open(file, O_RDONLY);

	if (fd < 0) {

		error(INFO, "unable to open dump file %s\n", file);

		return -1;

	}

	if (lseek(fd, MAX_SIZE_MDF_HEADER, SEEK_SET) < 0) {

		error(INFO, "%s: seek error (flat format)\n", file);

		close(fd);

		return -1;

	}

	if (stat64(file, &stat) < 0) {

		error(INFO, "cannot stat64 %s\n", file);

                return -1;

	}

	please_wait("sorting flat format data");

	pct = last_pct = 0;

	while (1) {

		if (num_allocated <= num_stored) {

			num_allocated += 100;

			size_allocated = sizeof(struct flat_data)

					 * num_allocated;

			new = realloc(ptr, size_allocated);

			if (new == NULL) {

				error(INFO, 

				    "unable to realloc flat_data structures\n");

				break;

			}

			ptr = new;

		}

		offset_fdh = lseek(fd, 0x0, SEEK_CUR);

		if ((bytes_read = read(fd, &fdh, sizeof(fdh))) != sizeof(fdh)) {

			if (bytes_read >= 0)

				error(INFO, 

				    "read error: %s (flat format): truncated/incomplete\n", 

					file);

			else

				error(INFO, "read error: %s (flat format)\n", file);

			break;

		}

		if (!is_bigendian()){

			fdh.offset   = bswap_64(fdh.offset);

			fdh.buf_size = bswap_64(fdh.buf_size);

		}

		if (fdh.offset == END_FLAG_FLAT_HEADER) {

			result = TRUE;

			break;

		}

		cur = ptr + num_stored;

		sort_idx = num_stored;

		while (sort_idx) {

			new = ptr + --sort_idx;

			if (new->off_rearranged >= fdh.offset) {

				cur->off_flattened = new->off_flattened;

				cur->off_rearranged = new->off_rearranged;

				cur->buf_size = new->buf_size;

				cur = new;

			} else {

				if (CRASHDEBUG(1) && sort_idx + 1 != num_stored) {

					fprintf(fp,

						"makedumpfile: Moved from %lld to %lld\n",

						num_stored, sort_idx + 1);

				}

				break;

			}

		}

		cur->off_flattened  = offset_fdh + sizeof(fdh);

		cur->off_rearranged = fdh.offset;

		cur->buf_size       = fdh.buf_size;

		num_stored++;

		pct = (offset_fdh * 100ULL) / stat.st_size; 

		if (pct > last_pct) {

			sprintf(buf, "sorting flat format data: %lld%%", (ulonglong)pct);

			please_wait(buf);

			if (CRASHDEBUG(1))

				fprintf(fp, "\n");

			last_pct = pct;

		}

		if (CRASHDEBUG(1) && (fdh.offset >> 30) > (offset_report >> 30)) {

			fprintf(fp, "makedumpfile: At %lld GiB\n",

			      (ulonglong)(fdh.offset >> 30));

			offset_report = fdh.offset;

		}

		/* seek for next makedumpfile_data_header. */

		if (lseek(fd, fdh.buf_size, SEEK_CUR) < 0) {

			error(INFO, "%s: seek error (flat format)\n", file);

			break;

		}

	}

	please_wait_done();

	close(fd);

	if (result == FALSE) {

		free(ptr);

		return -1;

	}

	*fda = ptr;

	return num_stored;

}

static int

read_all_makedumpfile_data_header(char *file)

{

	unsigned long long	num;

	struct flat_data	*fda = NULL;

	long long retval;

	retval = num = store_flat_data_array(file, &fda);

	if (retval < 0)

		return FALSE;

	afd.num_array = num;

	afd.array     = fda;

	return TRUE;

}

void

check_flattened_format(char *file)

{

	int fd, get_osrelease;

	struct stat stat;

	struct makedumpfile_header fh;

	if (pc->flags2 & GET_OSRELEASE) {

		get_osrelease = TRUE;

		pc->flags2 &= ~GET_OSRELEASE;

	} else

		get_osrelease = FALSE;

	if (flattened_format)

		goto out;

	if (file_exists(file, &stat) && S_ISCHR(stat.st_mode))

		goto out;

	fd = open(file, O_RDONLY);

	if (fd < 0) {

		error(INFO, "unable to open dump file %s\n", file);

		goto out;

	}

	if (read(fd, &fh, sizeof(fh)) < 0) {

		error(INFO, "unable to read dump file %s\n", file);

		close(fd);

		goto out;

	}

	close(fd);

	if (!is_bigendian()){

		fh.type    = bswap_64(fh.type);

		fh.version = bswap_64(fh.version);

	}

	if ((strncmp(fh.signature, MAKEDUMPFILE_SIGNATURE, sizeof(MAKEDUMPFILE_SIGNATURE)) != 0) || 

	    (fh.type != TYPE_FLAT_HEADER))

		goto out;

	if (get_osrelease) {

		flattened_format_get_osrelease(file);

		return;

	}

	if (!read_all_makedumpfile_data_header(file))

		return;

	if (CRASHDEBUG(1))

		fprintf(fp, "%s: FLAT\n\n", file);

	fh_save = fh;

	flattened_format = TRUE;

	return;

out:

	if (get_osrelease)

		pc->flags2 |= GET_OSRELEASE;

}

static int

read_raw_dump_file(int fd, off_t offset, void *buf, size_t size)

{

	if (lseek(fd, offset, SEEK_SET) < 0) {

		if (CRASHDEBUG(1))

			error(INFO, "read_raw_dump_file: lseek error (flat format)\n");

		return FALSE;

	}

	if (read(fd, buf, size) < size) {

		if (CRASHDEBUG(1))

			error(INFO, "read_raw_dump_file: read error (flat format)\n");

		return FALSE;

	}

	return TRUE;

}

int

read_flattened_format(int fd, off_t offset, void *buf, size_t size)

{

	unsigned long long	index, index_start, index_end;

	int64_t			range_start, range_end;

	size_t			read_size, remain_size;

	off_t			offset_read;

	struct flat_data	*ptr;

	index_start = 0;

	index_end   = afd.num_array;

	while (1) {

		index = (index_start + index_end) / 2;

		ptr = afd.array + index;

		range_start = ptr->off_rearranged;

		range_end   = ptr->off_rearranged + ptr->buf_size;

		if ((range_start <= offset) && (offset < range_end)) {

			/* Found a corresponding array. */

			offset_read = (offset - range_start) + ptr->off_flattened;

			if (offset + size <= range_end) {

				if (!read_raw_dump_file(fd, offset_read, buf, size))

					return FALSE;

				break;

			}

			/* Searh other array corresponding to remaining data. */

			read_size   = range_end - offset;

			remain_size = size - read_size;

			if (!read_raw_dump_file(fd, offset_read, buf, read_size))

				return FALSE;

			if (!read_flattened_format(fd, offset + read_size,

					(char *)buf + read_size, remain_size))

				return FALSE;

			break;

		} else if ((index == index_start) &&

			   (index_start + 1 == index_end)) {

			/*

			 * Try to read not-written area. That is a common case,

			 * because the area might be skipped by lseek().

			 * This area should be the data filled with zero.

			 */

			ptr = afd.array + index_end;

			if (offset + size <= ptr->off_rearranged) {

				memset(buf, 0x0, size);

			} else {

				read_size   = ptr->off_rearranged - offset;

				remain_size = size - read_size;

				memset(buf, 0x0, read_size);

				if (!read_flattened_format(fd,

						offset + read_size,

						(char *)buf + read_size,

						remain_size))

					return FALSE;

			}

			break;

		} else if (offset < ptr->off_rearranged)

			index_end   = index;

		else

			index_start = index;

	}

	return TRUE;

}

int

is_flattened_format(char *file)

{

	check_flattened_format(file);

	return flattened_format;

}

void

dump_flat_header(FILE *ofp)

{

        int i;

	fprintf(ofp, "makedumpfile header:\n");

	fprintf(ofp, "          signature: \"");

	for (i = 0; i < SIG_LEN_MDF; i++) {

		if (!fh_save.signature[i])

			break;

		fprintf(ofp, "%c", fh_save.signature[i]);

	}

	fprintf(ofp, "\"\n");

	fprintf(ofp, "               type: %llx\n", (ulonglong)fh_save.type);

	fprintf(ofp, "            version: %llx\n", (ulonglong)fh_save.version);

	fprintf(ofp, "      all_flat_data:\n");

	fprintf(ofp, "          num_array: %lld\n", (ulonglong)afd.num_array);

	fprintf(ofp, "              array: %lx\n", (ulong)afd.array);

	fprintf(ofp, "          file_size: %ld\n\n", (ulong)afd.file_size);

}

static void 

flattened_format_get_osrelease(char *file)

{

	int c;

	FILE *pipe;

	char buf[BUFSIZE], *p1, *p2;

	c = strlen("OSRELEASE=");

	sprintf(buf, "/usr/bin/strings -n %d %s", c, file);

	if ((pipe = popen(buf, "r")) == NULL)

		return;

        for (c = 0; (c < 100) && fgets(buf, BUFSIZE-1, pipe); c++) {

		if ((p1 = strstr(buf, "OSRELEASE="))) {

			p2 = strstr(p1, "=");

			fprintf(fp, "%s", p2+1);

			flattened_format = TRUE;

			pc->flags2 |= GET_OSRELEASE;

		}

	}

	fclose(pipe);

}