| Message ID | 20240214153827.1087657-3-tusharsu@linux.microsoft.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
| Series | ima: kexec: measure events between kexec load and execute | expand |
On 2/14/24 10:38, Tushar Sugandhi wrote: > Currently, the mechanism to map and unmap segments to the kimage > structure is not available to the subsystems outside of kexec. This > functionality is needed when IMA is allocating the memory segments > during kexec 'load' operation. Implement functions to map and unmap > segments to kimage. > > Implement kimage_map_segment() to enable mapping of IMA buffer source > pages to the kimage structure post kexec 'load'. This function, > accepting a kimage pointer, an address, and a size, will gather the > source pages within the specified address range, create an array of page > pointers, and map these to a contiguous virtual address range. The > function returns the start of this range if successful, or NULL if > unsuccessful. > > Implement kimage_unmap_segment() for unmapping segments > using vunmap(). Relocate 'for_each_kimage_entry()' macro from > kexec_core.c to kexec.h for broader accessibility. > > Signed-off-by: Tushar Sugandhi <tusharsu@linux.microsoft.com> > --- > include/linux/kexec.h | 13 ++++++++++ > kernel/kexec_core.c | 59 +++++++++++++++++++++++++++++++++++++++---- > 2 files changed, 67 insertions(+), 5 deletions(-) > > diff --git a/include/linux/kexec.h b/include/linux/kexec.h > index 400cb6c02176..3145447eb77a 100644 > --- a/include/linux/kexec.h > +++ b/include/linux/kexec.h > @@ -486,6 +486,11 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) { > static inline void arch_crash_handle_hotplug_event(struct kimage *image) { } > #endif > > +#define for_each_kimage_entry(image, ptr, entry) \ > + for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ > + ptr = (entry & IND_INDIRECTION) ? \ > + boot_phys_to_virt((entry & PAGE_MASK)) : ptr + 1) > + > int crash_check_update_elfcorehdr(void); > > #ifndef crash_hotplug_cpu_support > @@ -507,6 +512,10 @@ extern bool kexec_file_dbg_print; > kexec_file_dbg_print ? KERN_INFO : KERN_DEBUG, \ > ##__VA_ARGS__) > > +extern void *kimage_map_segment(struct kimage *image, > + unsigned long addr, unsigned long size); > +extern void kimage_unmap_segment(void *buffer); > + > #else /* !CONFIG_KEXEC_CORE */ > struct pt_regs; > struct task_struct; > @@ -514,6 +523,10 @@ static inline void __crash_kexec(struct pt_regs *regs) { } > static inline void crash_kexec(struct pt_regs *regs) { } > static inline int kexec_should_crash(struct task_struct *p) { return 0; } > static inline int kexec_crash_loaded(void) { return 0; } > +static inline void *kimage_map_segment(struct kimage *image, > + unsigned long addr, unsigned long size) > +{ return NULL; } > +static inline void kimage_unmap_segment(void *buffer) { } > #define kexec_in_progress false > #endif /* CONFIG_KEXEC_CORE */ > > diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c > index d08fc7b5db97..612ad8783bab 100644 > --- a/kernel/kexec_core.c > +++ b/kernel/kexec_core.c > @@ -582,11 +582,6 @@ void kimage_terminate(struct kimage *image) > *image->entry = IND_DONE; > } > > -#define for_each_kimage_entry(image, ptr, entry) \ > - for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ > - ptr = (entry & IND_INDIRECTION) ? \ > - boot_phys_to_virt((entry & PAGE_MASK)) : ptr + 1) > - > static void kimage_free_entry(kimage_entry_t entry) > { > struct page *page; > @@ -909,6 +904,60 @@ int kimage_load_segment(struct kimage *image, > return result; > } > > +void *kimage_map_segment(struct kimage *image, > + unsigned long addr, unsigned long size) > +{ > + unsigned long eaddr = addr + size; > + unsigned long src_page_addr, dest_page_addr; > + unsigned int npages; > + struct page **src_pages; > + int i; > + kimage_entry_t *ptr, entry; > + void *vaddr = NULL; > + > + /* > + * Collect the source pages and map them in a contiguous VA range. > + */ > + npages = PFN_UP(eaddr) - PFN_DOWN(addr); > + src_pages = kmalloc_array(npages, sizeof(*src_pages), GFP_KERNEL); > + if (!src_pages) { > + pr_err("%s: Could not allocate ima pages array.\n", __func__); > + return NULL; > + } > + > + i = 0; > + for_each_kimage_entry(image, ptr, entry) { > + if (entry & IND_DESTINATION) > + dest_page_addr = entry & PAGE_MASK; > + else if (entry & IND_SOURCE) { > + if (dest_page_addr >= addr && dest_page_addr < eaddr) { > + src_page_addr = entry & PAGE_MASK; > + src_pages[i++] = > + virt_to_page(__va(src_page_addr)); > + if (i == npages) > + break; > + dest_page_addr += PAGE_SIZE; > + } > + } > + } > + > + /* Sanity check. */ > + WARN_ON(i < npages); > + > + vaddr = vmap(src_pages, npages, VM_MAP, PAGE_KERNEL); > + kfree(src_pages); > + > + if (!vaddr) > + pr_err("%s: Could not map ima buffer.\n", __func__); > + > + return vaddr; > +} > + > +void kimage_unmap_segment(void *segment_buffer) > +{ > + vunmap(segment_buffer); > +} > + > struct kexec_load_limit { > /* Mutex protects the limit count. */ > struct mutex mutex; Reviewed-by: Stefan Berger <stefanb@linux.ibm.com>
On 2/14/24 11:43, Stefan Berger wrote:
> Reviewed-by: Stefan Berger <stefanb@linux.ibm.com>
Thanks for the tag Stefan.
On Wed, 2024-02-14 at 07:38 -0800, Tushar Sugandhi wrote: > Currently, the mechanism to map and unmap segments to the kimage > structure is not available to the subsystems outside of kexec. This > functionality is needed when IMA is allocating the memory segments > during kexec 'load' operation. Implement functions to map and unmap > segments to kimage. > > Implement kimage_map_segment() to enable mapping of IMA buffer source > pages to the kimage structure post kexec 'load'. This function, > accepting a kimage pointer, an address, and a size, will gather the > source pages within the specified address range, create an array of page > pointers, and map these to a contiguous virtual address range. The > function returns the start of this range if successful, or NULL if > unsuccessful. > > Implement kimage_unmap_segment() for unmapping segments > using vunmap(). Relocate 'for_each_kimage_entry()' macro from > kexec_core.c to kexec.h for broader accessibility. > > Signed-off-by: Tushar Sugandhi <tusharsu@linux.microsoft.com> > --- > include/linux/kexec.h | 13 ++++++++++ > kernel/kexec_core.c | 59 +++++++++++++++++++++++++++++++++++++++---- > 2 files changed, 67 insertions(+), 5 deletions(-) > > diff --git a/include/linux/kexec.h b/include/linux/kexec.h > index 400cb6c02176..3145447eb77a 100644 > --- a/include/linux/kexec.h > +++ b/include/linux/kexec.h > @@ -486,6 +486,11 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, > unsigned int pages) { > static inline void arch_crash_handle_hotplug_event(struct kimage *image) { } > #endif > > +#define for_each_kimage_entry(image, ptr, entry) \ > + for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ > + ptr = (entry & IND_INDIRECTION) ? \ > + boot_phys_to_virt((entry & PAGE_MASK)) : ptr + 1) > + I don't see a reason for moving this macro. Mimi
diff --git a/include/linux/kexec.h b/include/linux/kexec.h index 400cb6c02176..3145447eb77a 100644 --- a/include/linux/kexec.h +++ b/include/linux/kexec.h @@ -486,6 +486,11 @@ static inline void arch_kexec_pre_free_pages(void *vaddr, unsigned int pages) { static inline void arch_crash_handle_hotplug_event(struct kimage *image) { } #endif +#define for_each_kimage_entry(image, ptr, entry) \ + for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ + ptr = (entry & IND_INDIRECTION) ? \ + boot_phys_to_virt((entry & PAGE_MASK)) : ptr + 1) + int crash_check_update_elfcorehdr(void); #ifndef crash_hotplug_cpu_support @@ -507,6 +512,10 @@ extern bool kexec_file_dbg_print; kexec_file_dbg_print ? KERN_INFO : KERN_DEBUG, \ ##__VA_ARGS__) +extern void *kimage_map_segment(struct kimage *image, + unsigned long addr, unsigned long size); +extern void kimage_unmap_segment(void *buffer); + #else /* !CONFIG_KEXEC_CORE */ struct pt_regs; struct task_struct; @@ -514,6 +523,10 @@ static inline void __crash_kexec(struct pt_regs *regs) { } static inline void crash_kexec(struct pt_regs *regs) { } static inline int kexec_should_crash(struct task_struct *p) { return 0; } static inline int kexec_crash_loaded(void) { return 0; } +static inline void *kimage_map_segment(struct kimage *image, + unsigned long addr, unsigned long size) +{ return NULL; } +static inline void kimage_unmap_segment(void *buffer) { } #define kexec_in_progress false #endif /* CONFIG_KEXEC_CORE */ diff --git a/kernel/kexec_core.c b/kernel/kexec_core.c index d08fc7b5db97..612ad8783bab 100644 --- a/kernel/kexec_core.c +++ b/kernel/kexec_core.c @@ -582,11 +582,6 @@ void kimage_terminate(struct kimage *image) *image->entry = IND_DONE; } -#define for_each_kimage_entry(image, ptr, entry) \ - for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \ - ptr = (entry & IND_INDIRECTION) ? \ - boot_phys_to_virt((entry & PAGE_MASK)) : ptr + 1) - static void kimage_free_entry(kimage_entry_t entry) { struct page *page; @@ -909,6 +904,60 @@ int kimage_load_segment(struct kimage *image, return result; } +void *kimage_map_segment(struct kimage *image, + unsigned long addr, unsigned long size) +{ + unsigned long eaddr = addr + size; + unsigned long src_page_addr, dest_page_addr; + unsigned int npages; + struct page **src_pages; + int i; + kimage_entry_t *ptr, entry; + void *vaddr = NULL; + + /* + * Collect the source pages and map them in a contiguous VA range. + */ + npages = PFN_UP(eaddr) - PFN_DOWN(addr); + src_pages = kmalloc_array(npages, sizeof(*src_pages), GFP_KERNEL); + if (!src_pages) { + pr_err("%s: Could not allocate ima pages array.\n", __func__); + return NULL; + } + + i = 0; + for_each_kimage_entry(image, ptr, entry) { + if (entry & IND_DESTINATION) + dest_page_addr = entry & PAGE_MASK; + else if (entry & IND_SOURCE) { + if (dest_page_addr >= addr && dest_page_addr < eaddr) { + src_page_addr = entry & PAGE_MASK; + src_pages[i++] = + virt_to_page(__va(src_page_addr)); + if (i == npages) + break; + dest_page_addr += PAGE_SIZE; + } + } + } + + /* Sanity check. */ + WARN_ON(i < npages); + + vaddr = vmap(src_pages, npages, VM_MAP, PAGE_KERNEL); + kfree(src_pages); + + if (!vaddr) + pr_err("%s: Could not map ima buffer.\n", __func__); + + return vaddr; +} + +void kimage_unmap_segment(void *segment_buffer) +{ + vunmap(segment_buffer); +} + struct kexec_load_limit { /* Mutex protects the limit count. */ struct mutex mutex;
Currently, the mechanism to map and unmap segments to the kimage structure is not available to the subsystems outside of kexec. This functionality is needed when IMA is allocating the memory segments during kexec 'load' operation. Implement functions to map and unmap segments to kimage. Implement kimage_map_segment() to enable mapping of IMA buffer source pages to the kimage structure post kexec 'load'. This function, accepting a kimage pointer, an address, and a size, will gather the source pages within the specified address range, create an array of page pointers, and map these to a contiguous virtual address range. The function returns the start of this range if successful, or NULL if unsuccessful. Implement kimage_unmap_segment() for unmapping segments using vunmap(). Relocate 'for_each_kimage_entry()' macro from kexec_core.c to kexec.h for broader accessibility. Signed-off-by: Tushar Sugandhi <tusharsu@linux.microsoft.com> --- include/linux/kexec.h | 13 ++++++++++ kernel/kexec_core.c | 59 +++++++++++++++++++++++++++++++++++++++---- 2 files changed, 67 insertions(+), 5 deletions(-)