[PATCH 2/2] Write out a whole part of the 1st bitmap before entering cyclic process

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

 



(2013/10/24 15:52), HATAYAMA Daisuke wrote:
> Currently, 1st bitmap is created during cyclic process, but the
> information represented by the 1st bitmap, originally present memory,
> is still available from ELF program header table, so we don't need to
> keep the 1st bitmap even in cyclic process.
>
> Supported is a conversion from ELF to kdump-compressed format only,
> not from ELF to ELF.
>
> Signed-off-by: HATAYAMA Daisuke <d.hatayama at jp.fujitsu.com>
> ---
>   makedumpfile.c |  224 +++++++++++++++++++++++++++++++++++++++++++++++++++-----
>   1 file changed, 202 insertions(+), 22 deletions(-)
>
> diff --git a/makedumpfile.c b/makedumpfile.c
> index 4b6c0ed..7440c97 100644
> --- a/makedumpfile.c
> +++ b/makedumpfile.c
> @@ -3055,7 +3055,8 @@ out:
>   				 * bufsize_cyclic is used to allocate 1st and 2nd bitmap,
>   				 * so it should be truncated to the half of free_memory.
>   				 */
> -				info->bufsize_cyclic = free_memory / 2;
> +				if (info->flag_elf_dumpfile)
> +					info->bufsize_cyclic = free_memory / 2;
>   			}
>   		}

I think here should be changed like below:

		if (info->flag_elf_dumpfile)
			info->bufsize_cyclic = free_memory / 2;
		else
			info->bufsize_cyclic = free_memory;


Thanks
Atsushi Kumagai

>
> @@ -3328,6 +3329,33 @@ clear_bit_on_2nd_bitmap_for_kernel(unsigned long long pfn)
>   	return clear_bit_on_2nd_bitmap(pfn);
>   }
>
> +int
> +set_bit_on_2nd_bitmap(unsigned long long pfn)
> +{
> +	if (info->flag_cyclic) {
> +		return set_bitmap_cyclic(info->partial_bitmap2, pfn, 1);
> +	} else {
> +		return set_bitmap(info->bitmap2, pfn, 1);
> +	}
> +}
> +
> +int
> +set_bit_on_2nd_bitmap_for_kernel(unsigned long long pfn)
> +{
> +	unsigned long long maddr;
> +
> +	if (is_xen_memory()) {
> +		maddr = ptom_xen(pfn_to_paddr(pfn));
> +		if (maddr == NOT_PADDR) {
> +			ERRMSG("Can't convert a physical address(%llx) to machine address.\n",
> +			    pfn_to_paddr(pfn));
> +			return FALSE;
> +		}
> +		pfn = paddr_to_pfn(maddr);
> +	}
> +	return set_bit_on_2nd_bitmap(pfn);
> +}
> +
>   static inline int
>   is_in_segs(unsigned long long paddr)
>   {
> @@ -4418,6 +4446,53 @@ exclude_zero_pages(void)
>   	return TRUE;
>   }
>
> +static int
> +initialize_2nd_bitmap_cyclic(void)
> +{
> +	int i;
> +	unsigned long long pfn;
> +	unsigned long long phys_start, phys_end;
> +	unsigned long long pfn_start, pfn_end;
> +	unsigned long long pfn_start_roundup, pfn_end_round;
> +	unsigned long pfn_start_byte, pfn_end_byte;
> +
> +	/*
> +	 * At first, clear all the bits on the 2nd-bitmap.
> +	 */
> +	initialize_bitmap_cyclic(info->partial_bitmap2);
> +
> +	/*
> +	 * If page is on memory hole, set bit on the 2nd-bitmap.
> +	 */
> +	for (i = 0; get_pt_load(i, &phys_start, &phys_end, NULL, NULL); i++) {
> +		pfn_start = MAX(paddr_to_pfn(phys_start), info->cyclic_start_pfn);
> +		pfn_end = MIN(paddr_to_pfn(phys_end), info->cyclic_end_pfn);
> +
> +		if (pfn_start >= pfn_end)
> +			continue;
> +
> +		pfn_start_roundup = roundup(pfn_start, BITPERBYTE);
> +		pfn_end_round = round(pfn_end, BITPERBYTE);
> +
> +		for (pfn = pfn_start; pfn < pfn_start_roundup; ++pfn)
> +			if (!set_bit_on_2nd_bitmap_for_kernel(pfn))
> +				return FALSE;
> +
> +		pfn_start_byte = (pfn_start_roundup - info->cyclic_start_pfn) >> 3;
> +		pfn_end_byte = (pfn_end_round - info->cyclic_start_pfn) >> 3;
> +
> +		memset(info->partial_bitmap2 + pfn_start_byte,
> +		       0xff,
> +		       pfn_end_byte - pfn_start_byte);
> +
> +		for (pfn = pfn_end_round; pfn < pfn_end; ++pfn)
> +			if (!set_bit_on_2nd_bitmap_for_kernel(pfn))
> +				return FALSE;
> +	}
> +
> +	return TRUE;
> +}
> +
>   int
>   __exclude_unnecessary_pages(unsigned long mem_map,
>       unsigned long long pfn_start, unsigned long long pfn_end)
> @@ -4584,12 +4659,6 @@ exclude_unnecessary_pages(void)
>   	return TRUE;
>   }
>
> -void
> -copy_bitmap_cyclic(void)
> -{
> -	memcpy(info->partial_bitmap2, info->partial_bitmap1, info->bufsize_cyclic);
> -}
> -
>   int
>   exclude_unnecessary_pages_cyclic(void)
>   {
> @@ -4597,10 +4666,8 @@ exclude_unnecessary_pages_cyclic(void)
>   	struct mem_map_data *mmd;
>   	struct timeval tv_start;
>
> -	/*
> -	 * Copy 1st-bitmap to 2nd-bitmap.
> -	 */
> -	copy_bitmap_cyclic();
> +	if (!initialize_2nd_bitmap_cyclic())
> +		return FALSE;
>
>   	if ((info->dump_level & DL_EXCLUDE_FREE) && !info->page_is_buddy)
>   		if (!exclude_free_page())
> @@ -4657,7 +4724,7 @@ update_cyclic_region(unsigned long long pfn)
>   	if (info->cyclic_end_pfn > info->max_mapnr)
>   		info->cyclic_end_pfn = info->max_mapnr;
>
> -	if (!create_1st_bitmap_cyclic())
> +	if (info->flag_elf_dumpfile && !create_1st_bitmap_cyclic())
>   		return FALSE;
>
>   	if (!exclude_unnecessary_pages_cyclic())
> @@ -4841,19 +4908,71 @@ prepare_bitmap_buffer_cyclic(void)
>   	return TRUE;
>   }
>
> +int
> +prepare_bitmap1_buffer_cyclic(void)
> +{
> +	/*
> +	 * Prepare partial bitmap buffers for cyclic processing.
> +	 */
> +	if ((info->partial_bitmap1 = (char *)malloc(info->bufsize_cyclic)) == NULL) {
> +		ERRMSG("Can't allocate memory for the 1st bitmaps. %s\n",
> +		       strerror(errno));
> +		return FALSE;
> +	}
> +	initialize_bitmap_cyclic(info->partial_bitmap1);
> +
> +	return TRUE;
> +}
> +
> +int
> +prepare_bitmap2_buffer_cyclic(void)
> +{
> +	unsigned long tmp;
> +
> +	/*
> +	 * Create 2 bitmaps (1st-bitmap & 2nd-bitmap) on block_size
> +	 * boundary. The crash utility requires both of them to be
> +	 * aligned to block_size boundary.
> +	 */
> +	tmp = divideup(divideup(info->max_mapnr, BITPERBYTE), info->page_size);
> +	info->len_bitmap = tmp * info->page_size * 2;
> +
> +	/*
> +	 * Prepare partial bitmap buffers for cyclic processing.
> +	 */
> +	if ((info->partial_bitmap2 = (char *)malloc(info->bufsize_cyclic)) == NULL) {
> +		ERRMSG("Can't allocate memory for the 2nd bitmaps. %s\n",
> +		       strerror(errno));
> +		return FALSE;
> +	}
> +	initialize_bitmap_cyclic(info->partial_bitmap2);
> +
> +	return TRUE;
> +}
> +
>   void
> -free_bitmap_buffer(void)
> +free_bitmap1_buffer(void)
>   {
>   	if (info->bitmap1) {
>   		free(info->bitmap1);
>   		info->bitmap1 = NULL;
>   	}
> +}
> +
> +void
> +free_bitmap2_buffer(void)
> +{
>   	if (info->bitmap2) {
>   		free(info->bitmap2);
>   		info->bitmap2 = NULL;
>   	}
> +}
>
> -	return;
> +void
> +free_bitmap_buffer(void)
> +{
> +	free_bitmap1_buffer();
> +	free_bitmap2_buffer();
>   }
>
>   int
> @@ -4862,10 +4981,21 @@ create_dump_bitmap(void)
>   	int ret = FALSE;
>
>   	if (info->flag_cyclic) {
> -		if (!prepare_bitmap_buffer_cyclic())
> -			goto out;
>
> -		info->num_dumpable = get_num_dumpable_cyclic();
> +		if (info->flag_elf_dumpfile) {
> +			if (!prepare_bitmap_buffer_cyclic())
> +				goto out;
> +
> +			info->num_dumpable = get_num_dumpable_cyclic();
> +		} else {
> +			if (!prepare_bitmap2_buffer_cyclic())
> +				goto out;
> +
> +			info->num_dumpable = get_num_dumpable_cyclic();
> +
> +			free_bitmap2_buffer();
> +		}
> +
>   	} else {
>   		if (!prepare_bitmap_buffer())
>   			goto out;
> @@ -6564,7 +6694,7 @@ out:
>   }
>
>   int
> -write_kdump_bitmap_cyclic(void)
> +write_kdump_bitmap1_cyclic(void)
>   {
>   	off_t offset;
>           int increment;
> @@ -6576,10 +6706,30 @@ write_kdump_bitmap_cyclic(void)
>   		return FALSE;
>
>   	offset = info->offset_bitmap1;
> -	if (!write_buffer(info->fd_dumpfile, offset,
> +	if (!write_buffer(info->fd_dumpfile, offset + info->bufsize_cyclic *
> +			  (info->cyclic_start_pfn / info->pfn_cyclic),
>   			  info->partial_bitmap1, increment, info->name_dumpfile))
>   		goto out;
>
> +	ret = TRUE;
> +out:
> +	return ret;
> +}
> +
> +int
> +write_kdump_bitmap2_cyclic(void)
> +{
> +	off_t offset;
> +	int increment;
> +	int ret = FALSE;
> +
> +	increment = divideup(info->cyclic_end_pfn - info->cyclic_start_pfn,
> +			     BITPERBYTE);
> +
> +	if (info->flag_elf_dumpfile)
> +		return FALSE;
> +
> +	offset = info->offset_bitmap1;
>   	offset += info->len_bitmap / 2;
>   	if (!write_buffer(info->fd_dumpfile, offset,
>   			  info->partial_bitmap2, increment, info->name_dumpfile))
> @@ -6633,6 +6783,30 @@ write_kdump_pages_and_bitmap_cyclic(struct cache_data *cd_header, struct cache_d
>   	}
>
>   	/*
> +	 * Write the 1st bitmap
> +	 */
> +	if (!prepare_bitmap1_buffer_cyclic())
> +		return FALSE;
> +
> +	info->cyclic_start_pfn = 0;
> +	info->cyclic_end_pfn = 0;
> +	for (pfn = 0; pfn < info->max_mapnr; pfn++) {
> +		if (is_cyclic_region(pfn))
> +			continue;
> +		if (!update_cyclic_region(pfn))
> +			return FALSE;
> +		if (!create_1st_bitmap_cyclic())
> +			return FALSE;
> +		if (!write_kdump_bitmap1_cyclic())
> +			return FALSE;
> +	}
> +
> +	free_bitmap1_buffer();
> +
> +	if (!prepare_bitmap2_buffer_cyclic())
> +		return FALSE;
> +
> +	/*
>   	 * Write pages and bitmap cyclically.
>   	 */
>   	info->cyclic_start_pfn = 0;
> @@ -6647,7 +6821,7 @@ write_kdump_pages_and_bitmap_cyclic(struct cache_data *cd_header, struct cache_d
>   		if (!write_kdump_pages_cyclic(cd_header, cd_page, &pd_zero, &offset_data))
>   			return FALSE;
>
> -		if (!write_kdump_bitmap_cyclic())
> +		if (!write_kdump_bitmap2_cyclic())
>   			return FALSE;
>           }
>
> @@ -8681,8 +8855,14 @@ calculate_cyclic_buffer_size(void) {
>   	 * should be 40% of free memory to keep the size of cyclic buffer
>   	 * within 80% of free memory.
>   	 */
> -	free_size = get_free_memory_size() * 0.4;
> -	needed_size = (info->max_mapnr * 2) / BITPERBYTE;
> +	if (info->flag_elf_dumpfile) {
> +		free_size = get_free_memory_size() * 0.4;
> +		needed_size = (info->max_mapnr * 2) / BITPERBYTE;
> +	} else {
> +		free_size = get_free_memory_size() * 0.8;
> +		needed_size = info->max_mapnr / BITPERBYTE;
> +	}
> +
>   	/* if --split was specified cyclic buffer allocated per dump file */
>   	if (info->num_dumpfile > 1)
>   		needed_size /= info->num_dumpfile;
>
>
>





[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