[PATCH] Makedumpfile: vmcore size estimate

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Forget to mention only x86-64 is processed in this patch.

On 06/11/14 at 08:39pm, Baoquan He wrote:
> User want to get a rough estimate of vmcore size, then they can decide
> how much storage space is reserved for vmcore dumping. This can help them
> to deploy their machines better, possibly hundreds of machines.
> 
> In this draft patch, a new configuration option is added,
>     "--vmcore-estimate"
> User can execute below command to get a dumped kcore. Since kcore is a
> elf file to map the whole memory of current kernel, it's  equal to the
> memory of crash kernel though it's not exact. Content of kcore is dynamic
> though /proc/vmcore is fixed once crash happened. But for vmcore size
> estimate, it is better enough.
> 
> sudo makedumpfile -E -d 31 --vmcore-estimate /proc/kcore /var/crash/kcore-dump
> 
> Questions:
> 1. Or we can get the dumpable page numbers only, then calculate the estimated
> vmcore size by a predifined factor if it's kdump compressed dumping. E.g if
> lzo dump, we assume the compression ratio is 45%, then the estimate size is
> equal to: (dumpable page numbers) * 4096* 45%.
> 
> This is easier but too rough, does anybody like this better compared with the
> real dumping implemented in this draft patch.
> 
> 2. If dump the /proc/kcore, there's still a bug I can't fixed. When elf dump,
> in function write_elf_header()  it will pre-calculate a num_loads_dumpfile which
> is the number of program segment which will be dumped. However during dumping,
> the content of /proc/kcore is dynamic, the final num_loads_dumpfile may change
> when call write_elf_pages_cyclic/write_elf_pages(). This will cause the final
> dumped elf file has a bad file format. When you execute
> "readelf -a /var/crash/kcore-dump", you will be a little surprised.
> 
> 3. This is not a formal patch, if the final solution is decided, I will post a
> patch, maybe a patchset. If you have suggestions about the code or implementation,
> please post your comment.
> 
> Signed-off-by: Baoquan He <bhe at redhat.com>
> ---
>  elf_info.c     | 136 ++++++++++++++++--
>  elf_info.h     |  17 +++
>  makedumpfile.c | 438 +++++++++++++++++++++++++++++++++++++++++++++++++++++----
>  makedumpfile.h |   5 +
>  4 files changed, 560 insertions(+), 36 deletions(-)
> 
> diff --git a/elf_info.c b/elf_info.c
> index b277f69..1b05ad1 100644
> --- a/elf_info.c
> +++ b/elf_info.c
> @@ -36,16 +36,9 @@
>  
>  #define XEN_ELFNOTE_CRASH_INFO	(0x1000001)
>  
> -struct pt_load_segment {
> -	off_t			file_offset;
> -	unsigned long long	phys_start;
> -	unsigned long long	phys_end;
> -	unsigned long long	virt_start;
> -	unsigned long long	virt_end;
> -};
>  
>  static int			nr_cpus;             /* number of cpu */
> -static off_t			max_file_offset;
> +off_t			max_file_offset;
>  
>  /*
>   * File information about /proc/vmcore:
> @@ -60,9 +53,9 @@ static int			flags_memory;
>  /*
>   * PT_LOAD information about /proc/vmcore:
>   */
> -static unsigned int		num_pt_loads;
> -static struct pt_load_segment	*pt_loads;
> -static off_t			offset_pt_load_memory;
> +unsigned int		num_pt_loads;
> +struct pt_load_segment	*pt_loads;
> +off_t			offset_pt_load_memory;
>  
>  /*
>   * PT_NOTE information about /proc/vmcore:
> @@ -395,7 +388,49 @@ get_pt_note_info(void)
>  	return TRUE;
>  }
>  
> +#define UNINITIALIZED  ((ulong)(-1))
>  
> +#define SEEK_ERROR       (-1)
> +#define READ_ERROR       (-2)
> +int set_kcore_vmcoreinfo(uint64_t vmcoreinfo_addr, uint64_t vmcoreinfo_len)
> +{
> +	int i;
> +	ulong kvaddr;
> +	Elf64_Nhdr *note64;
> +	off_t offset;
> +	char note[MAX_SIZE_NHDR];
> +	int size_desc;
> +	off_t offset_desc;
> +
> +	offset = UNINITIALIZED;
> +	kvaddr = (ulong)vmcoreinfo_addr | PAGE_OFFSET;
> +
> +	for (i = 0; i < num_pt_loads; ++i) {
> +		struct pt_load_segment *p = &pt_loads[i];
> +		if ((kvaddr >= p->virt_start) && (kvaddr < p->virt_end)) {
> +			offset = (off_t)(kvaddr - p->virt_start) +
> +			(off_t)p->file_offset;
> +			break;
> +		}
> +	}
> +
> +	if (offset == UNINITIALIZED)
> +		return SEEK_ERROR;
> +
> +        if (lseek(fd_memory, offset, SEEK_SET) != offset)
> +		perror("lseek");
> +
> +	if (read(fd_memory, note, MAX_SIZE_NHDR) != MAX_SIZE_NHDR)
> +		return READ_ERROR;
> +
> +	note64 = (Elf64_Nhdr *)note;
> +	size_desc   = note_descsz(note);
> +	offset_desc = offset + offset_note_desc(note);
> +
> +	set_vmcoreinfo(offset_desc, size_desc);
> +
> +	return 0;
> +}
>  /*
>   * External functions.
>   */
> @@ -681,6 +716,55 @@ get_elf32_ehdr(int fd, char *filename, Elf32_Ehdr *ehdr)
>  	return TRUE;
>  }
>  
> +int
> +get_elf_loads(int fd, char *filename)
> +{
> +	int i, j, phnum, elf_format;
> +	Elf64_Phdr phdr;
> +
> +	/*
> +	 * Check ELF64 or ELF32.
> +	 */
> +	elf_format = check_elf_format(fd, filename, &phnum, &num_pt_loads);
> +	if (elf_format == ELF64)
> +		flags_memory |= MEMORY_ELF64;
> +	else if (elf_format != ELF32)
> +		return FALSE;
> +
> +	if (!num_pt_loads) {
> +		ERRMSG("Can't get the number of PT_LOAD.\n");
> +		return FALSE;
> +	}
> +
> +	/*
> +	 * The below file information will be used as /proc/vmcore.
> +	 */
> +	fd_memory   = fd;
> +	name_memory = filename;
> +
> +	pt_loads = calloc(sizeof(struct pt_load_segment), num_pt_loads);
> +	if (pt_loads == NULL) {
> +		ERRMSG("Can't allocate memory for the PT_LOAD. %s\n",
> +		    strerror(errno));
> +		return FALSE;
> +	}
> +	for (i = 0, j = 0; i < phnum; i++) {
> +		if (!get_phdr_memory(i, &phdr))
> +			return FALSE;
> +
> +		if (phdr.p_type != PT_LOAD)
> +			continue;
> +
> +		if (j >= num_pt_loads)
> +			return FALSE;
> +		if(!dump_Elf_load(&phdr, j))
> +			return FALSE;
> +		j++;
> +	}
> +
> +	return TRUE;
> +}
> +
>  /*
>   * Get ELF information about /proc/vmcore.
>   */
> @@ -826,6 +910,36 @@ get_phdr_memory(int index, Elf64_Phdr *phdr)
>  	return TRUE;
>  }
>  
> +int
> +get_phdr_load(int index, Elf64_Phdr *phdr)
> +{
> +	Elf32_Phdr phdr32;
> +
> +	if (is_elf64_memory()) { /* ELF64 */
> +		phdr->p_type = PT_LOAD;
> +		phdr->p_vaddr = pt_loads[index].virt_start;
> +		phdr->p_paddr = pt_loads[index].phys_start;
> +		phdr->p_memsz  = pt_loads[index].phys_end - pt_loads[index].phys_start;
> +		phdr->p_filesz = phdr->p_memsz;
> +		phdr->p_offset = pt_loads[index].file_offset;
> +	} else {
> +		if (!get_elf32_phdr(fd_memory, name_memory, index, &phdr32)) {
> +			ERRMSG("Can't find Phdr %d.\n", index);
> +			return FALSE;
> +		}
> +		memset(phdr, 0, sizeof(Elf64_Phdr));
> +		phdr->p_type   = phdr32.p_type;
> +		phdr->p_flags  = phdr32.p_flags;
> +		phdr->p_offset = phdr32.p_offset;
> +		phdr->p_vaddr  = phdr32.p_vaddr;
> +		phdr->p_paddr  = phdr32.p_paddr;
> +		phdr->p_filesz = phdr32.p_filesz;
> +		phdr->p_memsz  = phdr32.p_memsz;
> +		phdr->p_align  = phdr32.p_align;
> +	}
> +	return TRUE;
> +}
> +
>  off_t
>  get_offset_pt_load_memory(void)
>  {
> diff --git a/elf_info.h b/elf_info.h
> index 801faff..0c67d74 100644
> --- a/elf_info.h
> +++ b/elf_info.h
> @@ -27,6 +27,19 @@
>  
>  #define MAX_SIZE_NHDR	MAX(sizeof(Elf64_Nhdr), sizeof(Elf32_Nhdr))
>  
> +struct pt_load_segment {
> +	off_t			file_offset;
> +	unsigned long long	phys_start;
> +	unsigned long long	phys_end;
> +	unsigned long long	virt_start;
> +	unsigned long long	virt_end;
> +};
> +
> +extern off_t			max_file_offset;
> +extern unsigned int		num_pt_loads;
> +extern struct pt_load_segment	*pt_loads;
> +
> +extern off_t			offset_pt_load_memory;
>  
>  off_t paddr_to_offset(unsigned long long paddr);
>  off_t paddr_to_offset2(unsigned long long paddr, off_t hint);
> @@ -44,11 +57,14 @@ int get_elf64_ehdr(int fd, char *filename, Elf64_Ehdr *ehdr);
>  int get_elf32_ehdr(int fd, char *filename, Elf32_Ehdr *ehdr);
>  int get_elf_info(int fd, char *filename);
>  void free_elf_info(void);
> +int get_elf_loads(int fd, char *filename);
>  
>  int is_elf64_memory(void);
>  int is_xen_memory(void);
>  
>  int get_phnum_memory(void);
> +
> +int get_phdr_load(int index, Elf64_Phdr *phdr);
>  int get_phdr_memory(int index, Elf64_Phdr *phdr);
>  off_t get_offset_pt_load_memory(void);
>  int get_pt_load(int idx,
> @@ -68,6 +84,7 @@ void get_pt_note(off_t *offset, unsigned long *size);
>  int has_vmcoreinfo(void);
>  void set_vmcoreinfo(off_t offset, unsigned long size);
>  void get_vmcoreinfo(off_t *offset, unsigned long *size);
> +int set_kcore_vmcoreinfo(uint64_t vmcoreinfo_addr, uint64_t vmcoreinfo_len);
>  
>  int has_vmcoreinfo_xen(void);
>  void get_vmcoreinfo_xen(off_t *offset, unsigned long *size);
> diff --git a/makedumpfile.c b/makedumpfile.c
> index 34db997..ac02747 100644
> --- a/makedumpfile.c
> +++ b/makedumpfile.c
> @@ -5146,6 +5146,7 @@ create_dump_bitmap(void)
>  
>  	if (info->flag_cyclic) {
>  
> +		printf("create_dump_bitmap flag_cyclic\n");
>  		if (info->flag_elf_dumpfile) {
>  			if (!prepare_bitmap_buffer_cyclic())
>  				goto out;
> @@ -5189,14 +5190,23 @@ get_loads_dumpfile(void)
>  
>  	initialize_2nd_bitmap(&bitmap2);
>  
> -	if (!(phnum = get_phnum_memory()))
> -		return FALSE;
> -
> -	for (i = 0; i < phnum; i++) {
> -		if (!get_phdr_memory(i, &load))
> +	if (info->flag_vmcore_estimate) {
> +		phnum = num_pt_loads;
> +	} else {
> +		if (!(phnum = get_phnum_memory()))
>  			return FALSE;
> -		if (load.p_type != PT_LOAD)
> -			continue;
> +	}
> +
> +	for (i = 0; i < num_pt_loads; i++) {
> +		if (info->flag_vmcore_estimate) {
> +			get_phdr_load(i , &load);
> +		} else {
> +			if (!get_phdr_memory(i, &load))
> +				return FALSE;
> +
> +			if (load.p_type != PT_LOAD)
> +				continue;
> +		}
>  
>  		pfn_start = paddr_to_pfn(load.p_paddr);
>  		pfn_end   = paddr_to_pfn(load.p_paddr + load.p_memsz);
> @@ -5734,17 +5744,26 @@ write_elf_pages(struct cache_data *cd_header, struct cache_data *cd_page)
>  	off_seg_load    = info->offset_load_dumpfile;
>  	cd_page->offset = info->offset_load_dumpfile;
>  
> -	if (!(phnum = get_phnum_memory()))
> -		return FALSE;
> +	if (info->flag_vmcore_estimate) {
> +		phnum = num_pt_loads;
> +	} else { 
> +		if (!(phnum = get_phnum_memory()))
> +			return FALSE;
> +	}
>  
>  	gettimeofday(&tv_start, NULL);
>  
>  	for (i = 0; i < phnum; i++) {
> -		if (!get_phdr_memory(i, &load))
> -			return FALSE;
> +		if (info->flag_vmcore_estimate) {
> +			memset(&load, 0, sizeof(load));
> +			get_phdr_load(i , &load);
> +		} else {
> +			if (!get_phdr_memory(i, &load))
> +				return FALSE;
>  
> -		if (load.p_type != PT_LOAD)
> -			continue;
> +			if (load.p_type != PT_LOAD)
> +				continue;
> +		}
>  
>  		off_memory= load.p_offset;
>  		paddr     = load.p_paddr;
> @@ -5923,14 +5942,24 @@ get_loads_dumpfile_cyclic(void)
>  	Elf64_Phdr load;
>  	struct cycle cycle = {0};
>  
> -	if (!(phnum = get_phnum_memory()))
> -		return FALSE;
> +	if (info->flag_vmcore_estimate) {
> +		phnum = num_pt_loads;
> +	} else {
> +		if (!(phnum = get_phnum_memory()))
> +			return FALSE;
> +	}
>  
>  	for (i = 0; i < phnum; i++) {
> -		if (!get_phdr_memory(i, &load))
> -			return FALSE;
> -		if (load.p_type != PT_LOAD)
> -			continue;
> +		if (info->flag_vmcore_estimate) {
> +			memset(&load, 0, sizeof(load) );
> +			get_phdr_load(i , &load);
> +		} else {
> +			if (!get_phdr_memory(i, &load))
> +				return FALSE;
> +
> +			if (load.p_type != PT_LOAD)
> +				continue;
> +		}
>  
>  		pfn_start = paddr_to_pfn(load.p_paddr);
>  		pfn_end = paddr_to_pfn(load.p_paddr + load.p_memsz);
> @@ -6016,17 +6045,26 @@ write_elf_pages_cyclic(struct cache_data *cd_header, struct cache_data *cd_page)
>  	pfn_user = pfn_free = pfn_hwpoison = 0;
>  	pfn_memhole = info->max_mapnr;
>  
> -	if (!(phnum = get_phnum_memory()))
> -		return FALSE;
> +	if (info->flag_vmcore_estimate) {
> +		phnum = num_pt_loads;
> +	} else { 
> +		if (!(phnum = get_phnum_memory()))
> +			return FALSE;
> +	}
>  
>  	gettimeofday(&tv_start, NULL);
>  
>  	for (i = 0; i < phnum; i++) {
> -		if (!get_phdr_memory(i, &load))
> -			return FALSE;
> +		if (info->flag_vmcore_estimate) {
> +			memset(&load, 0, sizeof(load));
> +			get_phdr_load(i , &load);
> +		} else {
> +			if (!get_phdr_memory(i, &load))
> +				return FALSE;
>  
> -		if (load.p_type != PT_LOAD)
> -			continue;
> +			if (load.p_type != PT_LOAD)
> +				continue;
> +		}
>  
>  		off_memory= load.p_offset;
>  		paddr = load.p_paddr;
> @@ -8929,6 +8967,13 @@ check_param_for_creating_dumpfile(int argc, char *argv[])
>  		 */
>  		info->name_memory   = argv[optind];
>  
> +	} else if ((argc == optind + 2) && info->flag_vmcore_estimate) {
> +		/*
> +		 * Parameters for get the /proc/kcore to estimate
> +		 * the size of dumped vmcore
> +		 */
> +		info->name_memory   = argv[optind];
> +		info->name_dumpfile = argv[optind+1];
>  	} else
>  		return FALSE;
>  
> @@ -9011,6 +9056,332 @@ out:
>  	return free_size;
>  }
>  
> +struct memory_range {
> +        unsigned long long start, end;
> +};
> +
> +#define CRASH_RESERVED_MEM_NR   8
> +static struct memory_range crash_reserved_mem[CRASH_RESERVED_MEM_NR];
> +static int crash_reserved_mem_nr;
> +
> +/*
> + * iomem_for_each_line()
> + *
> + * Iterate over each line in the file returned by proc_iomem(). If match is
> + * NULL or if the line matches with our match-pattern then call the
> + * callback if non-NULL.
> + *
> + * Return the number of lines matched.
> + */
> +int iomem_for_each_line(char *match,
> +			      int (*callback)(void *data,
> +					      int nr,
> +					      char *str,
> +					      unsigned long base,
> +					      unsigned long length),
> +			      void *data)
> +{
> +	const char iomem[] = "/proc/iomem";
> +	char line[MAX_LINE];
> +	FILE *fp;
> +	unsigned long long start, end, size;
> +	char *str;
> +	int consumed;
> +	int count;
> +	int nr = 0;
> +
> +	fp = fopen(iomem, "r");
> +	if (!fp) {
> +		ERRMSG("Cannot open %s\n", iomem);
> +		exit(1);
> +	}
> +
> +	while(fgets(line, sizeof(line), fp) != 0) {
> +		count = sscanf(line, "%Lx-%Lx : %n", &start, &end, &consumed);
> +		if (count != 2)
> +			continue;
> +		str = line + consumed;
> +		size = end - start + 1;
> +		if (!match || memcmp(str, match, strlen(match)) == 0) {
> +			if (callback
> +			    && callback(data, nr, str, start, size) < 0) {
> +				break;
> +			}
> +			nr++;
> +		}
> +	}
> +
> +	fclose(fp);
> +
> +	return nr;
> +}
> +
> +static int crashkernel_mem_callback(void *data, int nr,
> +                                          char *str,
> +                                          unsigned long base,
> +                                          unsigned long length)
> +{
> +        if (nr >= CRASH_RESERVED_MEM_NR)
> +                return 1;
> +
> +        crash_reserved_mem[nr].start = base;
> +        crash_reserved_mem[nr].end   = base + length - 1;
> +        return 0;
> +}
> +
> +int is_crashkernel_mem_reserved(void)
> +{
> +        int ret;
> +
> +        ret = iomem_for_each_line("Crash kernel\n",
> +                                        crashkernel_mem_callback, NULL);
> +        crash_reserved_mem_nr = ret;
> +
> +        return !!crash_reserved_mem_nr;
> +}
> +
> +/* Returns the physical address of start of crash notes buffer for a kernel. */
> +static int get_kernel_vmcoreinfo(uint64_t *addr, uint64_t *len)
> +{
> +	char line[MAX_LINE];
> +	int count;
> +	FILE *fp;
> +	unsigned long long temp, temp2;
> +
> +	*addr = 0;
> +	*len = 0;
> +
> +	if (!(fp = fopen("/sys/kernel/vmcoreinfo", "r")))
> +		return -1;
> +
> +	if (!fgets(line, sizeof(line), fp))
> +		ERRMSG("Cannot parse %s: %s\n", "/sys/kernel/vmcoreinfo", strerror(errno));
> +	count = sscanf(line, "%Lx %Lx", &temp, &temp2);
> +	if (count != 2)
> +		ERRMSG("Cannot parse %s: %s\n", "/sys/kernel/vmcoreinfo", strerror(errno));
> +
> +	*addr = (uint64_t) temp;
> +	*len = (uint64_t) temp2;
> +
> +	fclose(fp);
> +	return 0;
> +}
> +
> +
> +static int exclude_segment(struct pt_load_segment **pt_loads, unsigned int	*num_pt_loads, uint64_t start, uint64_t end)
> +{
> +        int i, j, tidx = -1;
> +	unsigned long long	vstart, vend, kvstart, kvend;
> +        struct pt_load_segment temp_seg = {0};
> +	kvstart = (ulong)start | PAGE_OFFSET;
> +	kvend = (ulong)end | PAGE_OFFSET;
> +	unsigned long size;
> +
> +        for (i = 0; i < (*num_pt_loads); i++) {
> +                vstart = (*pt_loads)[i].virt_start;
> +                vend = (*pt_loads)[i].virt_end;
> +                if (kvstart <  vend && kvend > vstart) {
> +                        if (kvstart != vstart && kvend != vend) {
> +				/* Split load segment */
> +				temp_seg.phys_start = end +1;
> +				temp_seg.phys_end = (*pt_loads)[i].phys_end;
> +				temp_seg.virt_start = kvend + 1;
> +				temp_seg.virt_end = vend;
> +				temp_seg.file_offset = (*pt_loads)[i].file_offset + temp_seg.virt_start - (*pt_loads)[i].virt_start;
> +
> +				(*pt_loads)[i].virt_end = kvstart - 1;
> +				(*pt_loads)[i].phys_end =  start -1;
> +
> +				tidx = i+1;
> +                        } else if (kvstart != vstart) {
> +				(*pt_loads)[i].phys_end = start - 1;
> +				(*pt_loads)[i].virt_end = kvstart - 1;
> +                        } else {
> +				(*pt_loads)[i].phys_start = end + 1;
> +				(*pt_loads)[i].virt_start = kvend + 1;
> +                        }
> +                }
> +        }
> +        /* Insert split load segment, if any. */
> +	if (tidx >= 0) {
> +		size = (*num_pt_loads + 1) * sizeof((*pt_loads)[0]);
> +		(*pt_loads) = realloc((*pt_loads), size);
> +		if  (!(*pt_loads) ) {
> +		    ERRMSG("Cannot realloc %ld bytes: %s\n",
> +		            size + 0UL, strerror(errno));
> +			exit(1);
> +		}
> +		for (j = (*num_pt_loads - 1); j >= tidx; j--)
> +		        (*pt_loads)[j+1] = (*pt_loads)[j];
> +		(*pt_loads)[tidx] = temp_seg;
> +		(*num_pt_loads)++;
> +        }
> +        return 0;
> +}
> +
> +static int
> +process_dump_load(struct pt_load_segment	*pls)
> +{
> +	unsigned long long paddr;
> +
> +	paddr = vaddr_to_paddr(pls->virt_start);
> +	pls->phys_start  = paddr;
> +	pls->phys_end    = paddr + (pls->virt_end - pls->virt_start);
> +	MSG("process_dump_load\n");
> +	MSG("  phys_start : %llx\n", pls->phys_start);
> +	MSG("  phys_end   : %llx\n", pls->phys_end);
> +	MSG("  virt_start : %llx\n", pls->virt_start);
> +	MSG("  virt_end   : %llx\n", pls->virt_end);
> +
> +	return TRUE;
> +}
> +
> +int get_kcore_dump_loads()
> +{
> +	struct pt_load_segment	*pls;
> +	int i, j, loads=0;
> +	unsigned long long paddr;
> +
> +	for (i = 0; i < num_pt_loads; ++i) {
> +		struct pt_load_segment *p = &pt_loads[i];
> +		if (is_vmalloc_addr(p->virt_start))
> +			continue;
> +		loads++;
> +	}
> +
> +	pls = calloc(sizeof(struct pt_load_segment), j);
> +	if (pls == NULL) {
> +		ERRMSG("Can't allocate memory for the PT_LOAD. %s\n",
> +		    strerror(errno));
> +		return FALSE;
> +	}
> +
> +	for (i = 0, j=0; i < num_pt_loads; ++i) {
> +		struct pt_load_segment *p = &pt_loads[i];
> +		if (is_vmalloc_addr(p->virt_start))
> +			continue;
> +		if (j >= loads)
> +			return FALSE;
> +
> +		if (j == 0) {
> +			offset_pt_load_memory = p->file_offset;
> +			if (offset_pt_load_memory == 0) {
> +				ERRMSG("Can't get the offset of page data.\n");
> +				return FALSE;
> +			}
> +		}
> +
> +		pls[j] = *p;
> +		process_dump_load(&pls[j]);
> +		j++;
> +	}
> +
> +	free(pt_loads);
> +	pt_loads = pls;
> +	num_pt_loads = loads;
> +
> +	for (i=0; i<crash_reserved_mem_nr; i++)
> +	{
> +		exclude_segment(&pt_loads, &num_pt_loads, crash_reserved_mem[i].start, crash_reserved_mem[i].end);
> +	}
> +
> +	max_file_offset = 0;
> +	for (i = 0; i < num_pt_loads; ++i) {
> +		struct pt_load_segment *p = &pt_loads[i];
> +		max_file_offset = MAX(max_file_offset,
> +				      p->file_offset + p->phys_end - p->phys_start);
> +	}
> +
> +	for (i = 0; i < num_pt_loads; ++i) {
> +		struct pt_load_segment *p = &pt_loads[i];
> +		MSG("LOAD (%d)\n", i);
> +		MSG("  phys_start : %llx\n", p->phys_start);
> +		MSG("  phys_end   : %llx\n", p->phys_end);
> +		MSG("  virt_start : %llx\n", p->virt_start);
> +		MSG("  virt_end   : %llx\n", p->virt_end);
> +	}
> +
> +	return TRUE;
> +}
> +
> +int get_page_offset()
> +{
> +	struct utsname utsname;
> +	if (uname(&utsname)) {
> +		ERRMSG("Cannot get name and information about current kernel : %s", strerror(errno));
> +		return FALSE;
> +	}
> +
> +	info->kernel_version = get_kernel_version(utsname.release);
> +	get_versiondep_info_x86_64();
> +	return TRUE;
> +}
> +
> +int vmcore_estimate(void)
> +{
> +	uint64_t vmcoreinfo_addr, vmcoreinfo_len;
> +	int num_retry, status;
> +
> +	if (!is_crashkernel_mem_reserved()) {
> +		ERRMSG("No memory is reserved for crashkenrel!\n");
> +		exit(1);
> +	}
> +
> +	get_page_offset();
> +
> +#if 1
> +	if (!open_dump_memory())
> +		return FALSE;
> +#endif
> +
> +	if (info->flag_vmcore_estimate) {
> +		if (!get_elf_loads(info->fd_memory, info->name_memory))
> +			return FALSE;
> +	}
> +
> +	if (get_kernel_vmcoreinfo(&vmcoreinfo_addr, &vmcoreinfo_len))
> +		return FALSE;
> +
> +	if (set_kcore_vmcoreinfo(vmcoreinfo_addr, vmcoreinfo_len))
> +		return FALSE;
> +
> +	if (!get_kcore_dump_loads())
> +		return FALSE;
> +
> +#if 1
> +	if (!initial())
> +		return FALSE;
> +#endif
> +
> +retry:
> +	if (!create_dump_bitmap())
> +		return FALSE;
> +
> +	if ((status = writeout_dumpfile()) == FALSE)
> +		return FALSE;
> +
> +	if (status == NOSPACE) {
> +		/*
> +		 * If specifying the other dump_level, makedumpfile tries
> +		 * to create a dumpfile with it again.
> +		 */
> +		num_retry++;
> +		if ((info->dump_level = get_next_dump_level(num_retry)) < 0)
> +			return FALSE;
> +		MSG("Retry to create a dumpfile by dump_level(%d).\n",
> +		    info->dump_level);
> +		if (!delete_dumpfile())
> +			return FALSE;
> +		goto retry;
> +	}
> +	print_report();
> +
> +	clear_filter_info();
> +	if (!close_files_for_creating_dumpfile())
> +		return FALSE;
> +
> +	return TRUE;
> +}
>  
>  /*
>   * Choose the lesser value of the two below as the size of cyclic buffer.
> @@ -9063,6 +9434,7 @@ static struct option longopts[] = {
>  	{"cyclic-buffer", required_argument, NULL, OPT_CYCLIC_BUFFER},
>  	{"eppic", required_argument, NULL, OPT_EPPIC},
>  	{"non-mmap", no_argument, NULL, OPT_NON_MMAP},
> +	{"vmcore-estimate", no_argument, NULL, OPT_VMCORE_ESTIMATE},
>  	{0, 0, 0, 0}
>  };
>  
> @@ -9154,6 +9526,9 @@ main(int argc, char *argv[])
>  		case OPT_DUMP_DMESG:
>  			info->flag_dmesg = 1;
>  			break;
> +		case OPT_VMCORE_ESTIMATE:
> +			info->flag_vmcore_estimate = 1;
> +			break;
>  		case OPT_COMPRESS_SNAPPY:
>  			info->flag_compress = DUMP_DH_COMPRESSED_SNAPPY;
>  			break;
> @@ -9294,6 +9669,19 @@ main(int argc, char *argv[])
>  
>  		MSG("\n");
>  		MSG("The dmesg log is saved to %s.\n", info->name_dumpfile);
> +	} else if (info->flag_vmcore_estimate) {
> +#if 1
> +		if (!check_param_for_creating_dumpfile(argc, argv)) {
> +			MSG("Commandline parameter is invalid.\n");
> +			MSG("Try `makedumpfile --help' for more information.\n");
> +			goto out;
> +		}
> +#endif
> +		if (!vmcore_estimate())
> +			goto out;
> +
> +		MSG("\n");
> +		MSG("vmcore size estimate successfully.\n");
>  	} else {
>  		if (!check_param_for_creating_dumpfile(argc, argv)) {
>  			MSG("Commandline parameter is invalid.\n");
> diff --git a/makedumpfile.h b/makedumpfile.h
> index 9402f05..c401337 100644
> --- a/makedumpfile.h
> +++ b/makedumpfile.h
> @@ -216,6 +216,9 @@ isAnon(unsigned long mapping)
>  #define FILENAME_STDOUT		"STDOUT"
>  #define MAP_REGION		(4096*1024)
>  
> +#define MAX_LINE	160
> +
> +
>  /*
>   * Minimam vmcore has 2 ProgramHeaderTables(PT_NOTE and PT_LOAD).
>   */
> @@ -910,6 +913,7 @@ struct DumpInfo {
>  	int		flag_force;	     /* overwrite existing stuff */
>  	int		flag_exclude_xen_dom;/* exclude Domain-U from xen-kdump */
>  	int             flag_dmesg;          /* dump the dmesg log out of the vmcore file */
> +	int             flag_vmcore_estimate;          /* estimate the size  of vmcore in current system */
>  	int		flag_use_printk_log; /* did we read printk_log symbol name? */
>  	int		flag_nospace;	     /* the flag of "No space on device" error */
>  	int		flag_vmemmap;        /* kernel supports vmemmap address space */
> @@ -1764,6 +1768,7 @@ struct elf_prstatus {
>  #define OPT_CYCLIC_BUFFER       OPT_START+11
>  #define OPT_EPPIC               OPT_START+12
>  #define OPT_NON_MMAP            OPT_START+13
> +#define OPT_VMCORE_ESTIMATE            OPT_START+14
>  
>  /*
>   * Function Prototype.
> -- 
> 1.8.5.3
> 
> 
> _______________________________________________
> kexec mailing list
> kexec at lists.infradead.org
> http://lists.infradead.org/mailman/listinfo/kexec



[Index of Archives]     [LM Sensors]     [Linux Sound]     [ALSA Users]     [ALSA Devel]     [Linux Audio Users]     [Linux Media]     [Kernel]     [Gimp]     [Yosemite News]     [Linux Media]

  Powered by Linux