/* * kexec: kexec_file_load system call * * Copyright (C) 2014 Red Hat Inc. * Authors: *      Vivek Goyal <vgoyal@redhat.com> * * This source code is licensed under the GNU General Public License, * Version 2.  See the file COPYING for more details. */ #include <linux/capability.h>#include <linux/mm.h>#include <linux/file.h>#include <linux/slab.h>#include <linux/kexec.h>#include <linux/mutex.h>#include <linux/list.h>#include <crypto/hash.h>#include <crypto/sha.h>#include <linux/syscalls.h>#include <linux/vmalloc.h>#include "kexec_internal.h" /* * Declare these symbols weak so that if architecture provides a purgatory, * these will be overridden. */char __weak kexec_purgatory[0];size_t __weak kexec_purgatory_size = 0; static int kexec_calculate_store_digests(struct kimage *image); static int copy_file_from_fd(int fd, void **buf, unsigned long *buf_len){	struct fd f = fdget(fd);	int ret;	struct kstat stat;	loff_t pos;	ssize_t bytes = 0; 	if (!f.file)		return -EBADF; 	ret = vfs_getattr(&f.file->f_path, &stat);	if (ret)		goto out; 	if (stat.size > INT_MAX) {		ret = -EFBIG;		goto out;	} 	/* Don't hand 0 to vmalloc, it whines. */	if (stat.size == 0) {		ret = -EINVAL;		goto out;	} 	*buf = vmalloc(stat.size);	if (!*buf) {		ret = -ENOMEM;		goto out;	} 	pos = 0;	while (pos < stat.size) {		bytes = kernel_read(f.file, pos, (char *)(*buf) + pos,				    stat.size - pos);		if (bytes < 0) {			vfree(*buf);			ret = bytes;			goto out;		} 		if (bytes == 0)			break;		pos += bytes;	} 	if (pos != stat.size) {		ret = -EBADF;		vfree(*buf);		goto out;	} 	*buf_len = pos;out:	fdput(f);	return ret;} /* Architectures can provide this probe function */int __weak arch_kexec_kernel_image_probe(struct kimage *image, void *buf,					 unsigned long buf_len){	return -ENOEXEC;} void * __weak arch_kexec_kernel_image_load(struct kimage *image){	return ERR_PTR(-ENOEXEC);} int __weak arch_kimage_file_post_load_cleanup(struct kimage *image){	return -EINVAL;} int __weak arch_kexec_kernel_verify_sig(struct kimage *image, void *buf,					unsigned long buf_len){	return -EKEYREJECTED;} /* Apply relocations of type RELA */int __weakarch_kexec_apply_relocations_add(const Elf_Ehdr *ehdr, Elf_Shdr *sechdrs,				 unsigned int relsec){	pr_err("RELA relocation unsupported.\n");	return -ENOEXEC;} /* Apply relocations of type REL */int __weakarch_kexec_apply_relocations(const Elf_Ehdr *ehdr, Elf_Shdr *sechdrs,			     unsigned int relsec){	pr_err("REL relocation unsupported.\n");	return -ENOEXEC;} /* * Free up memory used by kernel, initrd, and command line. This is temporary * memory allocation which is not needed any more after these buffers have * been loaded into separate segments and have been copied elsewhere. */void kimage_file_post_load_cleanup(struct kimage *image){	struct purgatory_info *pi = &image->purgatory_info; 	vfree(image->kernel_buf);	image->kernel_buf = NULL; 	vfree(image->initrd_buf);	image->initrd_buf = NULL; 	kfree(image->cmdline_buf);	image->cmdline_buf = NULL; 	vfree(pi->purgatory_buf);	pi->purgatory_buf = NULL; 	vfree(pi->sechdrs);	pi->sechdrs = NULL; 	/* See if architecture has anything to cleanup post load */	arch_kimage_file_post_load_cleanup(image); 	/*	 * Above call should have called into bootloader to free up	 * any data stored in kimage->image_loader_data. It should	 * be ok now to free it up.	 */	kfree(image->image_loader_data);	image->image_loader_data = NULL;} /* * In file mode list of segments is prepared by kernel. Copy relevant * data from user space, do error checking, prepare segment list */static intkimage_file_prepare_segments(struct kimage *image, int kernel_fd, int initrd_fd,			     const char __user *cmdline_ptr,			     unsigned long cmdline_len, unsigned flags){	int ret = 0;	void *ldata; 	ret = copy_file_from_fd(kernel_fd, &image->kernel_buf,				&image->kernel_buf_len);	if (ret)		return ret; 	/* Call arch image probe handlers */	ret = arch_kexec_kernel_image_probe(image, image->kernel_buf,					    image->kernel_buf_len); 	if (ret)		goto out; #ifdef CONFIG_KEXEC_VERIFY_SIG	ret = arch_kexec_kernel_verify_sig(image, image->kernel_buf,					   image->kernel_buf_len);	if (ret) {		pr_debug("kernel signature verification failed.\n");		goto out;	}	pr_debug("kernel signature verification successful.\n");#endif	/* It is possible that there no initramfs is being loaded */	if (!(flags & KEXEC_FILE_NO_INITRAMFS)) {		ret = copy_file_from_fd(initrd_fd, &image->initrd_buf,					&image->initrd_buf_len);		if (ret)			goto out;	} 	if (cmdline_len) {		image->cmdline_buf = kzalloc(cmdline_len, GFP_KERNEL);		if (!image->cmdline_buf) {			ret = -ENOMEM;			goto out;		} 		ret = copy_from_user(image->cmdline_buf, cmdline_ptr,				     cmdline_len);		if (ret) {			ret = -EFAULT;			goto out;		} 		image->cmdline_buf_len = cmdline_len; 		/* command line should be a string with last byte null */		if (image->cmdline_buf[cmdline_len - 1] != '\0') {			ret = -EINVAL;			goto out;		}	} 	/* Call arch image load handlers */	ldata = arch_kexec_kernel_image_load(image); 	if (IS_ERR(ldata)) {		ret = PTR_ERR(ldata);		goto out;	} 	image->image_loader_data = ldata;out:	/* In case of error, free up all allocated memory in this function */	if (ret)		kimage_file_post_load_cleanup(image);	return ret;} static intkimage_file_alloc_init(struct kimage **rimage, int kernel_fd,		       int initrd_fd, const char __user *cmdline_ptr,		       unsigned long cmdline_len, unsigned long flags){	int ret;	struct kimage *image;	bool kexec_on_panic = flags & KEXEC_FILE_ON_CRASH; 	image = do_kimage_alloc_init();	if (!image)		return -ENOMEM; 	image->file_mode = 1; 	if (kexec_on_panic) {		/* Enable special crash kernel control page alloc policy. */		image->control_page = crashk_res.start;		image->type = KEXEC_TYPE_CRASH;	} 	ret = kimage_file_prepare_segments(image, kernel_fd, initrd_fd,					   cmdline_ptr, cmdline_len, flags);	if (ret)		goto out_free_image; 	ret = sanity_check_segment_list(image);	if (ret)		goto out_free_post_load_bufs; 	ret = -ENOMEM;	image->control_code_page = kimage_alloc_control_pages(image,					   get_order(KEXEC_CONTROL_PAGE_SIZE));	if (!image->control_code_page) {		pr_err("Could not allocate control_code_buffer\n");		goto out_free_post_load_bufs;	} 	if (!kexec_on_panic) {		image->swap_page = kimage_alloc_control_pages(image, 0);		if (!image->swap_page) {			pr_err("Could not allocate swap buffer\n");			goto out_free_control_pages;		}	} 	*rimage = image;	return 0;out_free_control_pages:	kimage_free_page_list(&image->control_pages);out_free_post_load_bufs:	kimage_file_post_load_cleanup(image);out_free_image:	kfree(image);	return ret;} SYSCALL_DEFINE5(kexec_file_load, int, kernel_fd, int, initrd_fd,		unsigned long, cmdline_len, const char __user *, cmdline_ptr,		unsigned long, flags){	int ret = 0, i;	struct kimage **dest_image, *image; 	/* We only trust the superuser with rebooting the system. */	if (!capable(CAP_SYS_BOOT) || kexec_load_disabled)		return -EPERM; 	/* Make sure we have a legal set of flags */	if (flags != (flags & KEXEC_FILE_FLAGS))		return -EINVAL; 	image = NULL; 	if (!mutex_trylock(&kexec_mutex))		return -EBUSY; 	dest_image = &kexec_image;	if (flags & KEXEC_FILE_ON_CRASH)		dest_image = &kexec_crash_image; 	if (flags & KEXEC_FILE_UNLOAD)		goto exchange; 	/*	 * In case of crash, new kernel gets loaded in reserved region. It is	 * same memory where old crash kernel might be loaded. Free any	 * current crash dump kernel before we corrupt it.	 */	if (flags & KEXEC_FILE_ON_CRASH)		kimage_free(xchg(&kexec_crash_image, NULL)); 	ret = kimage_file_alloc_init(&image, kernel_fd, initrd_fd, cmdline_ptr,				     cmdline_len, flags);	if (ret)		goto out; 	ret = machine_kexec_prepare(image);	if (ret)		goto out; 	ret = kexec_calculate_store_digests(image);	if (ret)		goto out; 	for (i = 0; i < image->nr_segments; i++) {		struct kexec_segment *ksegment; 		ksegment = &image->segment[i];		pr_debug("Loading segment %d: buf=0x%p bufsz=0x%zx mem=0x%lx memsz=0x%zx\n",			 i, ksegment->buf, ksegment->bufsz, ksegment->mem,			 ksegment->memsz); 		ret = kimage_load_segment(image, &image->segment[i]);		if (ret)			goto out;	} 	kimage_terminate(image); 	/*	 * Free up any temporary buffers allocated which are not needed	 * after image has been loaded	 */	kimage_file_post_load_cleanup(image);exchange:	image = xchg(dest_image, image);out:	mutex_unlock(&kexec_mutex);	kimage_free(image);	return ret;} static int locate_mem_hole_top_down(unsigned long start, unsigned long end,				    struct kexec_buf *kbuf){	struct kimage *image = kbuf->image;	unsigned long temp_start, temp_end; 	temp_end = min(end, kbuf->buf_max);	temp_start = temp_end - kbuf->memsz; 	do {		/* align down start */		temp_start = temp_start & (~(kbuf->buf_align - 1)); 		if (temp_start < start || temp_start < kbuf->buf_min)			return 0; 		temp_end = temp_start + kbuf->memsz - 1; 		/*		 * Make sure this does not conflict with any of existing		 * segments		 */		if (kimage_is_destination_range(image, temp_start, temp_end)) {			temp_start = temp_start - PAGE_SIZE;			continue;		} 		/* We found a suitable memory range */		break;	} while (1); 	/* If we are here, we found a suitable memory range */	kbuf->mem = temp_start; 	/* Success, stop navigating through remaining System RAM ranges */	return 1;} static int locate_mem_hole_bottom_up(unsigned long start, unsigned long end,				     struct kexec_buf *kbuf){	struct kimage *image = kbuf->image;	unsigned long temp_start, temp_end; 	temp_start = max(start, kbuf->buf_min); 	do {		temp_start = ALIGN(temp_start, kbuf->buf_align);		temp_end = temp_start + kbuf->memsz - 1; 		if (temp_end > end || temp_end > kbuf->buf_max)			return 0;		/*		 * Make sure this does not conflict with any of existing		 * segments		 */		if (kimage_is_destination_range(image, temp_start, temp_end)) {			temp_start = temp_start + PAGE_SIZE;			continue;		} 		/* We found a suitable memory range */		break;	} while (1); 	/* If we are here, we found a suitable memory range */	kbuf->mem = temp_start; 	/* Success, stop navigating through remaining System RAM ranges */	return 1;} static int locate_mem_hole_callback(u64 start, u64 end, void *arg){	struct kexec_buf *kbuf = (struct kexec_buf *)arg;	unsigned long sz = end - start + 1; 	/* Returning 0 will take to next memory range */	if (sz < kbuf->memsz)		return 0; 	if (end < kbuf->buf_min || start > kbuf->buf_max)		return 0; 	/*	 * Allocate memory top down with-in ram range. Otherwise bottom up	 * allocation.	 */	if (kbuf->top_down)		return locate_mem_hole_top_down(start, end, kbuf);	return locate_mem_hole_bottom_up(start, end, kbuf);} /* * Helper function for placing a buffer in a kexec segment. This assumes * that kexec_mutex is held. */int kexec_add_buffer(struct kimage *image, char *buffer, unsigned long bufsz,		     unsigned long memsz, unsigned long buf_align,		     unsigned long buf_min, unsigned long buf_max,		     bool top_down, unsigned long *load_addr){ 	struct kexec_segment *ksegment;	struct kexec_buf buf, *kbuf;	int ret; 	/* Currently adding segment this way is allowed only in file mode */	if (!image->file_mode)		return -EINVAL; 	if (image->nr_segments >= KEXEC_SEGMENT_MAX)		return -EINVAL; 	/*	 * Make sure we are not trying to add buffer after allocating	 * control pages. All segments need to be placed first before	 * any control pages are allocated. As control page allocation

Lines 1–500 of 1045. Load more