Segment registers abstraction is done to allow i386 => x86_64 COMPAT=y migration.
What is unsupported is in cr_arch_check_task_struct(). FIXME: support more that busyloop. Signed-off-by: Alexey Dobriyan <[email protected]> --- arch/x86/include/asm/unistd_32.h | 2 arch/x86/kernel/syscall_table_32.S | 2 include/linux/cr.h | 39 ++++++ kernel/cr/Makefile | 1 kernel/cr/cr-x86_32.c | 211 +++++++++++++++++++++++++++++++++++++ kernel/cr/cr.h | 2 6 files changed, 256 insertions(+), 1 deletion(-) --- a/arch/x86/include/asm/unistd_32.h +++ b/arch/x86/include/asm/unistd_32.h @@ -340,6 +340,8 @@ #define __NR_inotify_init1 332 #define __NR_preadv 333 #define __NR_pwritev 334 +#define __NR_checkpoint 335 +#define __NR_restart 336 #ifdef __KERNEL__ --- a/arch/x86/kernel/syscall_table_32.S +++ b/arch/x86/kernel/syscall_table_32.S @@ -334,3 +334,5 @@ ENTRY(sys_call_table) .long sys_inotify_init1 .long sys_preadv .long sys_pwritev + .long sys_checkpoint /* 335 */ + .long sys_restart --- a/include/linux/cr.h +++ b/include/linux/cr.h @@ -17,6 +17,7 @@ struct cr_image_header { /* Mutable part. */ /* Arch of the kernel which dumped the image. */ +#define CR_ARCH_X86_32 1 __le32 cr_arch; /* * Distributions are expected to leave image version alone and @@ -59,6 +60,44 @@ struct cr_image_task_struct { __u32 cr_len_arch; } __packed; +#define CR_SEG_NULL 0 +#define CR_SEG_USER32_CS 1 +#define CR_SEG_USER32_DS 2 +#define CR_SEG_USER64_CS 3 +#define CR_SEG_USER64_DS 4 +#define CR_SEG_TLS 0x4000 /* 0100 0000 0000 00xx */ +#define CR_SEG_LDT 0x8000 /* 100x xxxx xxxx xxxx */ + +struct cr_image_arch_x86_32 { + __u32 cr_ebx; + __u32 cr_ecx; + __u32 cr_edx; + __u32 cr_esi; + __u32 cr_edi; + __u32 cr_ebp; + __u32 cr_eax; + __u32 cr_orig_eax; + __u32 cr_eip; + __u32 cr_eflags; + __u32 cr_esp; + + __u16 cr_cs; + __u16 cr_ds; + __u16 cr_es; + __u16 cr_fs; + __u16 cr_gs; + __u16 cr_ss; + + __u32 cr_dr0; + __u32 cr_dr1; + __u32 cr_dr2; + __u32 cr_dr3; + __u32 cr_dr6; + __u32 cr_dr7; + + __u64 cr_tls_array[3]; +} __packed; + struct cr_image_mm_struct { struct cr_object_header cr_hdr; --- a/kernel/cr/Makefile +++ b/kernel/cr/Makefile @@ -4,3 +4,4 @@ cr-y += cr-context.o cr-y += cr-file.o cr-y += cr-mm.o cr-y += cr-task.o +cr-$(CONFIG_X86_32) += cr-x86_32.o new file mode 100644 --- /dev/null +++ b/kernel/cr/cr-x86_32.c @@ -0,0 +1,211 @@ +/* Copyright (C) 2000-2009 Parallels Holdings, Ltd. */ +#include <linux/sched.h> + +#include <linux/cr.h> +#include "cr.h" + +__u32 cr_image_header_arch(void) +{ + return CR_ARCH_X86_32; +} + +int cr_arch_check_image_header(struct cr_image_header *i) +{ + if (i->cr_arch == cpu_to_le32(CR_ARCH_X86_32)) + return 0; + return -EINVAL; +} + +__u32 cr_task_struct_arch(struct task_struct *tsk) +{ + return CR_ARCH_X86_32; +} + +int cr_arch_check_image_task_struct(struct cr_image_task_struct *i) +{ + if (i->cr_tsk_arch != CR_ARCH_X86_32) + return -EINVAL; + return 0; +} + +unsigned int cr_arch_len_task_struct(struct task_struct *tsk) +{ + return sizeof(struct cr_image_arch_x86_32); +} + +int cr_arch_check_task_struct(struct task_struct *tsk) +{ + if (tsk->thread.xstate) { + WARN_ON(1); + return -EINVAL; + } + if (tsk->thread.vm86_info) { + WARN_ON(1); + return -EINVAL; + } + if (tsk->thread.io_bitmap_ptr) { + WARN_ON(1); + return -EINVAL; + } +#ifdef CONFIG_X86_DS + if (tsk->thread.ds_ctx) { + WARN_ON(1); + return -EINVAL; + } +#endif + return 0; +} + +static __u16 encode_segment(u16 reg) +{ + if (reg == 0) + return CR_SEG_NULL; + BUG_ON((reg & 3) != 3); + if (reg & 4) + return CR_SEG_LDT | (reg >> 3); + + if (reg == __USER_CS) + return CR_SEG_USER32_CS; + if (reg == __USER_DS) + return CR_SEG_USER32_DS; + + if (GDT_ENTRY_TLS_MIN <= (reg >> 3) && (reg >> 3) <= GDT_ENTRY_TLS_MAX) + return CR_SEG_TLS | ((reg >> 3) - GDT_ENTRY_TLS_MIN); + BUG(); +} + +static u16 decode_segment(__u16 reg) +{ + if (reg == CR_SEG_NULL) + return 0; + + if (reg == CR_SEG_USER32_CS) + return __USER_CS; + if (reg == CR_SEG_USER32_DS) + return __USER_DS; + + BUILD_BUG_ON(GDT_ENTRY_TLS_MAX - GDT_ENTRY_TLS_MIN + 1 != 3); + if ((reg & CR_SEG_TLS) == CR_SEG_TLS) { + reg &= ~CR_SEG_TLS; + if (reg <= GDT_ENTRY_TLS_MAX - GDT_ENTRY_TLS_MIN) + return ((GDT_ENTRY_TLS_MIN + reg) << 3) | 3; + } + if ((reg & CR_SEG_LDT) == CR_SEG_LDT) { + reg &= ~CR_SEG_LDT; + return (reg << 3) | 7; + } + BUG(); +} + +int cr_arch_dump_task_struct(struct cr_context *ctx, struct task_struct *tsk) +{ + struct cr_image_arch_x86_32 *i; + struct pt_regs *regs = task_pt_regs(tsk); + int rv; + + i = kzalloc(sizeof(*i), GFP_KERNEL); + if (!i) + return -ENOMEM; + + i->cr_ebx = regs->bx; + i->cr_ecx = regs->cx; + i->cr_edx = regs->dx; + i->cr_esi = regs->si; + i->cr_edi = regs->di; + i->cr_ebp = regs->bp; + i->cr_eax = regs->ax; + i->cr_orig_eax = regs->orig_ax; + i->cr_eip = regs->ip; + i->cr_eflags = regs->flags; + i->cr_esp = regs->sp; + + i->cr_cs = encode_segment(regs->cs); + i->cr_ds = encode_segment(regs->ds); + i->cr_es = encode_segment(regs->es); + i->cr_fs = encode_segment(regs->fs); + i->cr_gs = encode_segment(tsk->thread.gs); + i->cr_ss = encode_segment(regs->ss); + + i->cr_dr0 = tsk->thread.debugreg0; + i->cr_dr1 = tsk->thread.debugreg1; + i->cr_dr2 = tsk->thread.debugreg2; + i->cr_dr3 = tsk->thread.debugreg3; + i->cr_dr6 = tsk->thread.debugreg6; + i->cr_dr7 = tsk->thread.debugreg7; + + BUILD_BUG_ON(sizeof(tsk->thread.tls_array[0]) != 8); + BUILD_BUG_ON(sizeof(tsk->thread.tls_array) != 3 * 8); + memcpy(i->cr_tls_array, tsk->thread.tls_array, sizeof(i->cr_tls_array)); + + rv = cr_write(ctx, i, sizeof(*i)); + kfree(i); + return rv; +} + +asmlinkage void ret_from_fork(void); +static int cr_restore_task_struct_x86_32(struct task_struct *tsk, struct cr_image_arch_x86_32 *i) +{ + struct pt_regs *regs = task_pt_regs(tsk); + + tsk->thread.sp = (unsigned long)regs; + tsk->thread.sp0 = (unsigned long)(regs + 1); + tsk->thread.ip = (unsigned long)ret_from_fork; + + regs->bx = i->cr_ebx; + regs->cx = i->cr_ecx; + regs->dx = i->cr_edx; + regs->si = i->cr_esi; + regs->di = i->cr_edi; + regs->bp = i->cr_ebp; + regs->ax = i->cr_eax; + regs->orig_ax = i->cr_orig_eax; + regs->ip = i->cr_eip; + regs->flags = i->cr_eflags; + regs->sp = i->cr_esp; + + regs->cs = decode_segment(i->cr_cs); + regs->ds = decode_segment(i->cr_ds); + regs->es = decode_segment(i->cr_es); + regs->fs = decode_segment(i->cr_fs); + tsk->thread.gs = decode_segment(i->cr_gs); + regs->ss = decode_segment(i->cr_ss); + + tsk->thread.debugreg0 = i->cr_dr0; + tsk->thread.debugreg1 = i->cr_dr1; + tsk->thread.debugreg2 = i->cr_dr2; + tsk->thread.debugreg3 = i->cr_dr3; + tsk->thread.debugreg6 = i->cr_dr6; + tsk->thread.debugreg7 = i->cr_dr7; + + memcpy(tsk->thread.tls_array, i->cr_tls_array, 3 * 8); + + return 0; +} + +int cr_arch_restore_task_struct(struct task_struct *tsk, struct cr_image_task_struct *i) +{ + struct cr_image_arch_x86_32 *arch_i = (struct cr_image_arch_x86_32 *)(i + 1); + + return cr_restore_task_struct_x86_32(tsk, arch_i); +} + +int cr_arch_check_mm_struct(struct mm_struct *mm) +{ + mutex_lock(&mm->context.lock); + if (mm->context.ldt || mm->context.size != 0) { + mutex_unlock(&mm->context.lock); + WARN_ON(1); + return -EINVAL; + } + return 0; +} + +unsigned int cr_arch_len_mm_struct(struct mm_struct *mm) +{ + return 0; +} + +int cr_arch_dump_mm_struct(struct cr_context *ctx, struct mm_struct *mm) +{ + return 0; +} --- a/kernel/cr/cr.h +++ b/kernel/cr/cr.h @@ -78,7 +78,7 @@ int cr_restore_file(struct cr_context *ctx, loff_t pos); int cr_restore_mm_struct(struct cr_context *ctx, loff_t pos); int cr_restore_task_struct(struct cr_context *ctx, loff_t pos); -#if 0 +#if defined(CONFIG_X86_32) __u32 cr_image_header_arch(void); int cr_arch_check_image_header(struct cr_image_header *i); _______________________________________________ Containers mailing list [email protected] https://lists.linux-foundation.org/mailman/listinfo/containers _______________________________________________ Devel mailing list [email protected] https://openvz.org/mailman/listinfo/devel
