Kdump之kexec源码分析

知道kexec还是在linuxsir上看到一篇介绍其应用的帖子, 经常用kexec快速启动内核的步骤如下:
(1).kexec -l <kernel-image> --append="<command-line-options>" [--initrd=xxxxxxxxxxx一般是要的,不过某些情况下可选]
例如: kexec -l /boot/vmlinuz-2.6.31  --append="root=/dev/sda6 ro nomce vga=0x317" --initrd=xxxxxxxxxxx
(2).kexec -e
再或者用kexec -p

下面仅分析kexe -l  & -e的形式

int main(int argc, char *argv[]) {     int do_load = 1;     int do_exec = 0;     int do_load_jump_back_helper = 0;     int do_shutdown = 1;     int do_sync = 1;     int do_ifdown = 0;     int do_unload = 0;     int do_reuse_initrd = 0;     void *entry = 0;     char *type = 0;     char *endptr;     int opt;     int result = 0;     int fileind;     static const struct option options[] = {         KEXEC_ARCH_OPTIONS         { 0, 0, 0, 0},     };     static const char short_options[] = KEXEC_OPT_STR;     opterr = 0; /* Don't complain about unrecognized options here */     while ((opt = getopt_long(argc, argv, short_options,                  options, 0)) != -1) {         switch(opt) {         case OPT_HELP:             usage();             return 0;         case OPT_VERSION:             version();             return 0;         case OPT_NOIFDOWN:             do_ifdown = 0;             break;         case OPT_FORCE:             do_load = 1;             do_shutdown = 0;             do_sync = 1;             do_ifdown = 1;             do_exec = 1;             break;         case OPT_LOAD://here1:             do_load = 1;             do_exec = 0;             do_shutdown = 0;             break;         case OPT_UNLOAD:             do_load = 0;             do_shutdown = 0;             do_sync = 0;             do_unload = 1;             break;         case OPT_EXEC://here3:             do_load = 0;             do_shutdown = 0;             do_sync = 1;             do_ifdown = 1;             do_exec = 1;             break;         case OPT_LOAD_JUMP_BACK_HELPER:             do_load = 0;             do_shutdown = 0;             do_sync = 1;             do_ifdown = 1;             do_exec = 0;             do_load_jump_back_helper = 1;             kexec_flags = KEXEC_PRESERVE_CONTEXT;             break;         case OPT_ENTRY:             entry = (void *)strtoul(optarg, &endptr, 0);             if (*endptr) {                 fprintf(stderr,                     "Bad option value in --load-jump-back-helper=%s\n",                     optarg);                 usage();                 return 1;             }             break;         case OPT_LOAD_PRESERVE_CONTEXT:             do_load = 1;             do_exec = 0;             do_shutdown = 0;             do_sync = 1;             kexec_flags = KEXEC_PRESERVE_CONTEXT;             break;         case OPT_TYPE:             type = optarg;             break;         case OPT_PANIC://here2:             do_load = 1;             do_exec = 0;             do_shutdown = 0;             do_sync = 0;             kexec_flags = KEXEC_ON_CRASH;             break;         case OPT_MEM_MIN:             mem_min = strtoul(optarg, &endptr, 0);             if (*endptr) {                 fprintf(stderr,                     "Bad option value in --mem-min=%s\n",                     optarg);                 usage();                 return 1;             }             break;         case OPT_MEM_MAX:             mem_max = strtoul(optarg, &endptr, 0);             if (*endptr) {                 fprintf(stderr,                     "Bad option value in --mem-max=%s\n",                     optarg);                 usage();                 return 1;             }             break;         case OPT_REUSE_INITRD:             do_reuse_initrd = 1;             break;         default:             break;         }     }     if ((kexec_flags & KEXEC_ON_CRASH) && !is_crashkernel_mem_reserved()) {         printf("Memory for crashkernel is not reserved\n");         printf("Please reserve memory by passing ");         printf("\"crashkernel=X@Y\" parameter to the kernel\n");         die("Then try loading kdump kernel\n");     }     if (do_load && (kexec_flags & KEXEC_PRESERVE_CONTEXT) &&      mem_max == ULONG_MAX) {         printf("Please specify memory range used by kexeced kernel\n");         printf("to preserve the context of original kernel with \n");         die("\"--mem-max\" parameter\n");     }     fileind = optind;     /* Reset getopt for the next pass; called in other source modules */     opterr = 1;     optind = 1;     result = arch_process_options(argc, argv);//先进来,一般情况下result返回为0     /* Check for bogus options */     if (!do_load) {         while((opt = getopt_long(argc, argv, short_options,                      options, 0)) != -1) {             if ((opt == '?') || (opt >= OPT_ARCH_MAX)) {                 usage();                 return 1;             }         }     }     if (do_reuse_initrd){         check_reuse_initrd();         arch_reuse_initrd();     }     if (do_unload) {         result = k_unload(kexec_flags);     }     if (do_load && (result == 0)) {//here1,here2:         result = my_load(type, fileind, argc, argv, kexec_flags, entry);//====>trap into     }     /* Don't shutdown unless there is something to reboot to! */     if ((result == 0) && (do_shutdown || do_exec) && !kexec_loaded()) {         die("Nothing has been loaded!\n");     }     if ((result == 0) && do_shutdown) {         result = my_shutdown();     }     if ((result == 0) && do_sync) {         sync();     }     if ((result == 0) && do_ifdown) {         ifdown();     }     if ((result == 0) && do_exec) {//here3:         result = my_exec();//=================>trap into     }     if ((result == 0) && do_load_jump_back_helper) {         result = my_load_jump_back_helper(kexec_flags, entry);     }     fflush(stdout);     fflush(stderr);     return result; }

/*  *    Load the new kernel  */ static int my_load(const char *type, int fileind, int argc, char **argv,          unsigned long kexec_flags, void *entry)//****************** {     char *kernel;     char *kernel_buf;     off_t kernel_size;     int i = 0;     int result;     struct kexec_info info;//1.注意这个结构体     long native_arch;     int guess_only = 0;     memset(&info, 0, sizeof(info));     info.segment = NULL;     info.nr_segments = 0;     info.entry = NULL;     info.backup_start = 0;     info.kexec_flags = kexec_flags;     result = 0;     if (argc - fileind <= 0) {         fprintf(stderr, "No kernel specified\n");         usage();         return -1;     }     kernel = argv[fileind];     /* slurp in the input kernel */     kernel_buf = slurp_decompress_file(kernel, &kernel_size);//kernel_buf中含有解压缩的内核 #if 0     fprintf(stderr, "kernel: %p kernel_size: %lx\n",         kernel_buf, kernel_size); #endif     if (get_memory_ranges(&info.memory_range, &info.memory_ranges,         info.kexec_flags) < 0) {         fprintf(stderr, "Could not get memory layout\n");         return -1;     }     /* if a kernel type was specified, try to honor it */     if (type) {         for (i = 0; i < file_types; i++) {             if (strcmp(type, file_type[i].name) == 0)                 break;         }         if (i == file_types) {             fprintf(stderr, "Unsupported kernel type %s\n", type);             return -1;         } else {             /* make sure our file is really of that type */    /*   此处用到的变量file_type的结构体 struct file_type {     const char *name;     probe_t *probe;     load_t  *load;     usage_t *usage; };//类似指定回调函数 struct file_type file_type[] = {     { "multiboot-x86", multiboot_x86_probe, multiboot_x86_load,       multiboot_x86_usage },     { "elf-x86", elf_x86_probe, elf_x86_load, elf_x86_usage },     { "bzImage", bzImage_probe, bzImage_load, bzImage_usage },     { "beoboot-x86", beoboot_probe, beoboot_load, beoboot_usage },     { "nbi-x86", nbi_probe, nbi_load, nbi_usage }, };    */             if (file_type[i].probe(kernel_buf, kernel_size) < 0)                 guess_only = 1;         }     }     if (!type || guess_only) {         for (i = 0; i < file_types; i++) {             if (file_type[i].probe(kernel_buf, kernel_size) >= 0)                 break;         }         if (i == file_types) {             fprintf(stderr, "Cannot determine the file type "                     "of %s\n", kernel);             return -1;         } else {             if (guess_only) {                 fprintf(stderr, "Wrong file type %s, "                     "file matches type %s\n",                     type, file_type[i].name);                 return -1;             }         }     }     if (file_type[i].load(argc, argv, kernel_buf,              kernel_size, &info) < 0) {//===========>trap into elf_x86_load         fprintf(stderr, "Cannot load %s\n", kernel);         return -1;     }     /* If we are not in native mode setup an appropriate trampoline */     native_arch = physical_arch();     if (native_arch < 0) {         return -1;     }     info.kexec_flags |= native_arch;     if (arch_compat_trampoline(&info) < 0) {         return -1;     }     if (info.kexec_flags & KEXEC_PRESERVE_CONTEXT) {         add_backup_segments(&info, mem_min, mem_max - mem_min + 1);     }     /* Verify all of the segments load to a valid location in memory */     for (i = 0; i < info.nr_segments; i++) {         if (!valid_memory_segment(&info, info.segment +i)) {             fprintf(stderr, "Invalid memory segment %p - %p\n",                 info.segment[i].mem,                 ((char *)info.segment[i].mem) +                 info.segment[i].memsz);             return -1;         }     }     /* Sort the segments and verify we don't have overlaps */     if (sort_segments(&info) < 0) {         return -1;     }     /* if purgatory is loaded update it */     update_purgatory(&info);//这个对新内核做下hash来进行完整性检测,,并将前640k保留起来(没仔细看，根据kdump相关资料猜得,可能有误,以后确认)     if (entry)         info.entry = entry; #if 0     fprintf(stderr, "kexec_load: entry = %p flags = %lx\n",         info.entry, info.kexec_flags);     print_segments(stderr, &info); #endif     result = kexec_load(         info.entry, info.nr_segments, info.segment, info.kexec_flags);//====================>     if (result != 0) {         /* The load failed, print some debugging information */         fprintf(stderr, "kexec_load failed: %s\n",             strerror(errno));         fprintf(stderr, "entry = %p flags = %lx\n",             info.entry, info.kexec_flags);         print_segments(stderr, &info);     }     return result; }

int elf_x86_load(int argc, char **argv, const char *buf, off_t len,     struct kexec_info *info)//****************** {     struct mem_ehdr ehdr;     const char *command_line;     char *modified_cmdline;     int command_line_len;     int modified_cmdline_len;     const char *ramdisk;     unsigned long entry, max_addr;     int arg_style; #define ARG_STYLE_ELF 0 #define ARG_STYLE_LINUX 1 #define ARG_STYLE_NONE 2     int opt; #define OPT_APPEND        (OPT_ARCH_MAX+0) #define OPT_REUSE_CMDLINE    (OPT_ARCH_MAX+1) #define OPT_RAMDISK        (OPT_ARCH_MAX+2) #define OPT_ARGS_ELF     (OPT_ARCH_MAX+3) #define OPT_ARGS_LINUX     (OPT_ARCH_MAX+4) #define OPT_ARGS_NONE     (OPT_ARCH_MAX+5)     static const struct option options[] = {         KEXEC_ARCH_OPTIONS         { "command-line",    1, NULL, OPT_APPEND },         { "append",        1, NULL, OPT_APPEND },         { "reuse-cmdline",    1, NULL, OPT_REUSE_CMDLINE },         { "initrd",        1, NULL, OPT_RAMDISK },         { "ramdisk",        1, NULL, OPT_RAMDISK },         { "args-elf",        0, NULL, OPT_ARGS_ELF },         { "args-linux",        0, NULL, OPT_ARGS_LINUX },         { "args-none",        0, NULL, OPT_ARGS_NONE },         { 0,             0, NULL, 0 },     };     static const char short_options[] = KEXEC_OPT_STR "";     /*      * Parse the command line arguments      */     arg_style = ARG_STYLE_ELF;     command_line = 0;     modified_cmdline = 0;     modified_cmdline_len = 0;     ramdisk = 0;     while((opt = getopt_long(argc, argv, short_options, options, 0)) != -1) {         switch(opt) {         default:             /* Ignore core options */             if (opt < OPT_ARCH_MAX) {                 break;             }         case '?':             usage();             return -1;         case OPT_APPEND:             command_line = optarg;             break;         case OPT_REUSE_CMDLINE:             command_line = get_command_line();             break;         case OPT_RAMDISK:             ramdisk = optarg;             break;         case OPT_ARGS_ELF:             arg_style = ARG_STYLE_ELF;             break;         case OPT_ARGS_LINUX:             arg_style = ARG_STYLE_LINUX;             break;         case OPT_ARGS_NONE: #ifdef __i386__             arg_style = ARG_STYLE_NONE; #else             die("--args-none only works on arch i386\n"); #endif             break;         }     }     command_line_len = 0;     if (command_line) {         command_line_len = strlen(command_line) +1;     }     /* Need to append some command line parameters internally in case of      * taking crash dumps.      */     if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) {         modified_cmdline = xmalloc(COMMAND_LINE_SIZE);         memset((void *)modified_cmdline, 0, COMMAND_LINE_SIZE);         if (command_line) {             strncpy(modified_cmdline, command_line,                         COMMAND_LINE_SIZE);             modified_cmdline[COMMAND_LINE_SIZE - 1] = '\0';         }         modified_cmdline_len = strlen(modified_cmdline);     }     /* Load the ELF executable 加载新内核，解析elf头并加载elf data，最终就是将内核各segmants(内核本质上就是一个ELF文件)弄到info中*/*/     elf_exec_build_load(info, &ehdr, buf, len, 0);//========================>     entry = ehdr.e_entry;     max_addr = elf_max_addr(&ehdr);     /* Do we want arguments? */     if (arg_style != ARG_STYLE_NONE) {         /* Load the setup code */         elf_rel_build_load(info, &info->rhdr, (char *) purgatory, purgatory_size,             0, ULONG_MAX, 1, 0);     }     if (arg_style == ARG_STYLE_NONE) {         info->entry = (void *)entry;     }     else if (arg_style == ARG_STYLE_ELF) {         unsigned long note_base;         struct entry32_regs regs;         uint32_t arg1, arg2;         /* Setup the ELF boot notes */         note_base = elf_boot_notes(info, max_addr,             (unsigned char *) command_line, command_line_len);         /* Initialize the stack arguments */         arg2 = 0; /* No return address */         arg1 = note_base;         elf_rel_set_symbol(&info->rhdr, "stack_arg32_1", &arg1, sizeof(arg1));         elf_rel_set_symbol(&info->rhdr, "stack_arg32_2", &arg2, sizeof(arg2));                  /* Initialize the registers */         elf_rel_get_symbol(&info->rhdr, "entry32_regs", &regs, sizeof(regs));         regs.eip = entry; /* The entry point */         regs.esp = elf_rel_get_addr(&info->rhdr, "stack_arg32_2");         elf_rel_set_symbol(&info->rhdr, "entry32_regs", &regs, sizeof(regs));         if (ramdisk) {             die("Ramdisks not supported with generic elf arguments");         }     }     else if (arg_style == ARG_STYLE_LINUX) {         struct x86_linux_faked_param_header *hdr;         unsigned long param_base;         const unsigned char *ramdisk_buf;         off_t ramdisk_length;         struct entry32_regs regs;         int rc = 0;         /* Get the linux parameter header */         hdr = xmalloc(sizeof(*hdr));         /* Hack: With some ld versions, vmlinux program headers show          * a gap of two pages between bss segment and data segment          * but effectively kernel considers it as bss segment and          * overwrites the any data placed there. Hence bloat the          * memsz of parameter segment to 16K to avoid being placed          * in such gaps.          * This is a makeshift solution until it is fixed in kernel          */         param_base = add_buffer(info, hdr, sizeof(*hdr), 16*1024,             16, 0, max_addr, 1);         /* Initialize the parameter header */         memset(hdr, 0, sizeof(*hdr));         init_linux_parameters(&hdr->hdr);         /* Add a ramdisk to the current image */         ramdisk_buf = NULL;         ramdisk_length = 0;         if (ramdisk) {             ramdisk_buf = (unsigned char *) slurp_file(ramdisk, &ramdisk_length);         }         /* If panic kernel is being loaded, additional segments need          * to be created. */         if (info->kexec_flags & (KEXEC_ON_CRASH|KEXEC_PRESERVE_CONTEXT)) {             rc = load_crashdump_segments(info, modified_cmdline,                         max_addr, 0);             if (rc < 0)                 return -1;             /* Use new command line. */             command_line = modified_cmdline;             command_line_len = strlen(modified_cmdline) + 1;         }         /* Tell the kernel what is going on */         setup_linux_bootloader_parameters(info, &hdr->hdr, param_base,             offsetof(struct x86_linux_faked_param_header, command_line),             command_line, command_line_len,             ramdisk_buf, ramdisk_length);         /* Fill in the information bios calls would usually provide */         setup_linux_system_parameters(&hdr->hdr, info->kexec_flags);         /* Initialize the registers */         elf_rel_get_symbol(&info->rhdr, "entry32_regs", &regs, sizeof(regs));         regs.ebx = 0;        /* Bootstrap processor */         regs.esi = param_base;    /* Pointer to the parameters */         regs.eip = entry;    /* The entry point */         regs.esp = elf_rel_get_addr(&info->rhdr, "stack_end"); /* Stack, unused */         elf_rel_set_symbol(&info->rhdr, "entry32_regs", &regs, sizeof(regs));     }     else {         die("Unknown argument style\n");     }     return 0; }

static inline long kexec_load(void *entry, unsigned long nr_segments,             struct kexec_segment *segments, unsigned long flags)//****************** {   //最终调用sys_kexec_load陷入内核     return (long) syscall(__NR_kexec_load, entry, nr_segments, segments, flags); }

看以下kexe -e执行的操作:

/*  * Exec the new kernel (reboot)  */ static int my_exec(void) {     int result;     result = kexec_reboot();     /* I have failed if I make it here */     fprintf(stderr, "kexec failed: %s\n",         strerror(errno));     return -1; } static inline long kexec_reboot(void) {   //最终调用sys_reboot,注意红色标志     return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KEXEC, 0); }

+++++++++++++++++++++++trap  into kernel,我是分隔线+++++++++++++++++++++++++++++

asmlinkage long sys_kexec_load(unsigned long entry, unsigned long nr_segments,                 struct kexec_segment __user *segments,                 unsigned long flags) {     struct kimage **dest_image, *image;     int locked;     int result;     /* We only trust the superuser with rebooting the system. */     if (!capable(CAP_SYS_BOOT))         return -EPERM;     /*      * Verify we have a legal set of flags      * This leaves us room for future extensions.      */     if ((flags & KEXEC_FLAGS) != (flags & ~KEXEC_ARCH_MASK))         return -EINVAL;     /* Verify we are on the appropriate architecture */     if (((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH) &&         ((flags & KEXEC_ARCH_MASK) != KEXEC_ARCH_DEFAULT))         return -EINVAL;     /* Put an artificial cap on the number      * of segments passed to kexec_load.      */     if (nr_segments > KEXEC_SEGMENT_MAX)         return -EINVAL;     image = NULL;     result = 0;     /* Because we write directly to the reserved memory      * region when loading crash kernels we need a mutex here to      * prevent multiple crash kernels from attempting to load      * simultaneously, and to prevent a crash kernel from loading      * over the top of a in use crash kernel.      *      * KISS: always take the mutex.      */     locked = xchg(&kexec_lock, 1);     if (locked)         return -EBUSY;     dest_image = &kexec_image;//选此个     if (flags & KEXEC_ON_CRASH)         dest_image = &kexec_crash_image;//kdump时     if (nr_segments > 0) {         unsigned long i;         /* Loading another kernel to reboot into */         if ((flags & KEXEC_ON_CRASH) == 0)//===========>kexec标志与后进入此             result = kimage_normal_alloc(&image, entry,                             nr_segments, segments);// 1.分配kimage和一个控制页空间，并拷贝各个段到内核空间         /* Loading another kernel to switch to if this one crashes */         else if (flags & KEXEC_ON_CRASH) {//kdump相关             /* Free any current crash dump kernel before              * we corrupt it.              */             kimage_free(xchg(&kexec_crash_image, NULL));             result = kimage_crash_alloc(&image, entry,                          nr_segments, segments);         }         if (result)             goto out;         result = machine_kexec_prepare(image);//x86为空         if (result)             goto out;         for (i = 0; i < nr_segments; i++) {             result = kimage_load_segment(image, &image->segment[i]);//加载各个段?????1.处不是做过了么,不太明白             if (result)                 goto out;         }         result = kimage_terminate(image);         if (result)             goto out;     }     /* Install the new kernel, and Uninstall the old */     image = xchg(dest_image, image);//应该是交换两个数据,将image的数据放到dest_image上????? out:     locked = xchg(&kexec_lock, 0); /* Release the mutex */     BUG_ON(!locked);     kimage_free(image);     return result; }

static int kimage_normal_alloc(struct kimage **rimage, unsigned long entry,                 unsigned long nr_segments,                 struct kexec_segment __user *segments) {     int result;     struct kimage *image;     /* Allocate and initialize a controlling structure */     image = NULL;     result = do_kimage_alloc(&image, entry, nr_segments, segments);//分配一个kimage大小的空间     if (result)         goto out;     *rimage = image;     /*      * Find a location for the control code buffer, and add it      * the vector of segments so that it's pages will also be      * counted as destination pages.      */     result = -ENOMEM;     image->control_code_page = kimage_alloc_control_pages(image,                      get_order(KEXEC_CONTROL_CODE_SIZE));//分配控制页     if (!image->control_code_page) {         printk(KERN_ERR "Could not allocate control_code_buffer\n");         goto out;     }     result = 0;  out:     if (result == 0)         *rimage = image;     else         kfree(image);     return result; }

简单小结下此阶段作的工作:
     就是将kexec -l命令行的新内核先拷贝到kernel_buf,然后再加载到结构体kexec_info info中,最后通过sys_kexec_load系统调用转移到动态内核内存页,这个系统调用给每个从用户空间传递而来的段分配动态内核页，并将段拷贝到这些内核页上



/*  * Reboot system call: for obvious reasons only root may call it,  * and even root needs to set up some magic numbers in the registers  * so that some mistake won't make this reboot the whole machine.  * You can also set the meaning of the ctrl-alt-del-key here.  *  * reboot doesn't sync: do that yourself before calling this.  */ asmlinkage long sys_reboot(int magic1, int magic2, unsigned int cmd, void __user * arg)// 0.kump相关=====> {     char buffer[256];     /* We only trust the superuser with rebooting the system. */     if (!capable(CAP_SYS_BOOT))         return -EPERM;     /* For safety, we require "magic" arguments. */     if (magic1 != LINUX_REBOOT_MAGIC1 ||      (magic2 != LINUX_REBOOT_MAGIC2 &&      magic2 != LINUX_REBOOT_MAGIC2A &&             magic2 != LINUX_REBOOT_MAGIC2B &&      magic2 != LINUX_REBOOT_MAGIC2C))         return -EINVAL;     /* Instead of trying to make the power_off code look like      * halt when pm_power_off is not set do it the easy way.      */     if ((cmd == LINUX_REBOOT_CMD_POWER_OFF) && !pm_power_off)         cmd = LINUX_REBOOT_CMD_HALT;     lock_kernel();     switch (cmd) {     case LINUX_REBOOT_CMD_RESTART:         kernel_restart(NULL);         break;     case LINUX_REBOOT_CMD_CAD_ON:         C_A_D = 1;         break;     case LINUX_REBOOT_CMD_CAD_OFF:         C_A_D = 0;         break;     case LINUX_REBOOT_CMD_HALT:         kernel_halt();         unlock_kernel();         do_exit(0);         break;     case LINUX_REBOOT_CMD_POWER_OFF:         kernel_power_off();         unlock_kernel();         do_exit(0);         break;     case LINUX_REBOOT_CMD_RESTART2:         if (strncpy_from_user(&buffer[0], arg, sizeof(buffer) - 1) < 0) {             unlock_kernel();             return -EFAULT;         }         buffer[sizeof(buffer) - 1] = '\0';         kernel_restart(buffer);         break;     case LINUX_REBOOT_CMD_KEXEC://还记得此标志否         kernel_kexec();//=========>         unlock_kernel();         return -EINVAL; #ifdef CONFIG_HIBERNATION     case LINUX_REBOOT_CMD_SW_SUSPEND:         {             int ret = hibernate();             unlock_kernel();             return ret;         } #endif     default:         unlock_kernel();         return -EINVAL;     }     unlock_kernel();     return 0; }

/**  *    kernel_kexec - reboot the system  *  *    Move into place and start executing a preloaded standalone  *    executable. If nothing was preloaded return an error.  */ static void kernel_kexec(void)// 1. kdump相关 { #ifdef CONFIG_KEXEC     struct kimage *image;     image = xchg(&kexec_image, NULL);     if (!image)         return;     kernel_restart_prepare(NULL);     printk(KERN_EMERG "Starting new kernel\n");     machine_shutdown();     machine_kexec(image);//===========> #endif }

/*  * Do not allocate memory (or fail in any way) in machine_kexec().  * We are past the point of no return, committed to rebooting now.  */ NORET_TYPE void machine_kexec(struct kimage *image)// 2. kdump相关========== {     unsigned long page_list[PAGES_NR];     void *control_page;     /* Interrupts aren't acceptable while we reboot */     local_irq_disable();     control_page = page_address(image->control_code_page);//kexec_crash_image是kexec -p时定义的?????     memcpy(control_page, relocate_kernel, PAGE_SIZE);     page_list[PA_CONTROL_PAGE] = __pa(control_page);//控制页     page_list[VA_CONTROL_PAGE] = (unsigned long)relocate_kernel;     page_list[PA_PGD] = __pa(kexec_pgd);     page_list[VA_PGD] = (unsigned long)kexec_pgd; #ifdef CONFIG_X86_PAE     page_list[PA_PMD_0] = __pa(kexec_pmd0);     page_list[VA_PMD_0] = (unsigned long)kexec_pmd0;     page_list[PA_PMD_1] = __pa(kexec_pmd1);     page_list[VA_PMD_1] = (unsigned long)kexec_pmd1; #endif     page_list[PA_PTE_0] = __pa(kexec_pte0);//两个页表kexec_pte0和kexec_pte1     page_list[VA_PTE_0] = (unsigned long)kexec_pte0;     page_list[PA_PTE_1] = __pa(kexec_pte1);     page_list[VA_PTE_1] = (unsigned long)kexec_pte1;     /* The segment registers are funny things, they have both a      * visible and an invisible part. Whenever the visible part is      * set to a specific selector, the invisible part is loaded      * with from a table in memory. At no other time is the      * descriptor table in memory accessed.      *      * I take advantage of this here by force loading the      * segments, before I zap the gdt with an invalid value.      */     load_segments();//将内核数据段( __KERNEL_DS )代码段( __KERNEL_CS )值装载到段寄存器     /* The gdt & idt are now invalid.      * If you want to load them you must set up your own idt & gdt.      */     set_gdt(phys_to_virt(0),0);//并使用 GDT 和 IDT 无效     set_idt(phys_to_virt(0),0);     /* now call it */     relocate_kernel((unsigned long)image->head, (unsigned long)page_list,             image->start, cpu_has_pae);//位于/arch/i386/kernel/relocate_kernel.s中============>trap into=========== }