[PATCH 23/38] C/R: x86_64 support

[Alexey Dobriyan <adobriyan@gmail.com>]

In theory and in practice, x86_64 COMPAT=y kernel will restore i386 images
and in other direction. There are small problems still and it doesn't work,
but mentioning anyway.

Right now x86_64 kernel restores only x86_64 images and 64-bit tasks.

Signed-off-by: Alexey Dobriyan <adobriyan@gmail.com>
---
 arch/x86/ia32/ia32entry.S        |    2 +
 arch/x86/include/asm/unistd_64.h |    4 +
 include/linux/kstate-image.h     |   36 ++++
 include/linux/kstate.h           |    2 +-
 kernel/kstate/Makefile           |    1 +
 kernel/kstate/kstate-x86_64.c    |  336 ++++++++++++++++++++++++++++++++++++++
 6 files changed, 380 insertions(+), 1 deletions(-)
 create mode 100644 kernel/kstate/kstate-x86_64.c

diff --git a/arch/x86/ia32/ia32entry.S b/arch/x86/ia32/ia32entry.S
index a505202..b12e911 100644
--- a/arch/x86/ia32/ia32entry.S
+++ b/arch/x86/ia32/ia32entry.S
@@ -830,4 +830,6 @@ ia32_sys_call_table:
 	.quad sys_inotify_init1
 	.quad compat_sys_preadv
 	.quad compat_sys_pwritev
+	.quad sys_checkpoint		/* 335 */
+	.quad sys_restart
 ia32_syscall_end:
diff --git a/arch/x86/include/asm/unistd_64.h b/arch/x86/include/asm/unistd_64.h
index f818294..a839c66 100644
--- a/arch/x86/include/asm/unistd_64.h
+++ b/arch/x86/include/asm/unistd_64.h
@@ -657,6 +657,10 @@ __SYSCALL(__NR_inotify_init1, sys_inotify_init1)
 __SYSCALL(__NR_preadv, sys_preadv)
 #define __NR_pwritev				296
 __SYSCALL(__NR_pwritev, sys_pwritev)
+#define __NR_checkpoint				297
+__SYSCALL(__NR_checkpoint, sys_checkpoint)
+#define __NR_restart				298
+__SYSCALL(__NR_restart, sys_restart)
 
 
 #ifndef __NO_STUBS
diff --git a/include/linux/kstate-image.h b/include/linux/kstate-image.h
index 3c93432..d697d97 100644
--- a/include/linux/kstate-image.h
+++ b/include/linux/kstate-image.h
@@ -28,6 +28,7 @@ struct kstate_image_header {
 	/* Mutable part. */
 	/* Arch of the kernel which dumped the image. */
 #define KSTATE_ARCH_I386	1
+#define KSTATE_ARCH_X86_64	2
 	__le32	kernel_arch;
 	/*
 	 * Distributions are expected to leave image version alone and
@@ -74,6 +75,8 @@ struct kstate_image_task_struct {
 #define KSTATE_SEG_NULL		0
 #define KSTATE_SEG_USER32_CS	1
 #define KSTATE_SEG_USER32_DS	2
+#define KSTATE_SEG_USER64_CS	3
+#define KSTATE_SEG_USER64_DS	4
 #define KSTATE_SEG_TLS		0x4000	/* 0100 0000 0000 00xx */
 #define KSTATE_SEG_LDT		0x8000	/* 100x xxxx xxxx xxxx */
 
@@ -110,6 +113,39 @@ struct kstate_image_task_struct_i386 {
 	/* __u8	xstate[len_xstate]; */
 } __packed;
 
+struct kstate_image_task_struct_x86_64 {
+	__u64		r15;
+	__u64		r14;
+	__u64		r13;
+	__u64		r12;
+	__u64		rbp;
+	__u64		rbx;
+	__u64		r11;
+	__u64		r10;
+	__u64		r9;
+	__u64		r8;
+	__u64		rax;
+	__u64		rcx;
+	__u64		rdx;
+	__u64		rsi;
+	__u64		rdi;
+	__u64		orig_rax;
+	__u64		rip;
+	__u64		rflags;
+	__u64		rsp;
+
+	__u64		fs;
+	__u64		gs;
+	__u16		cs;
+	__u16		ds;
+	__u16		es;
+	__u16		fsindex;
+	__u16		gsindex;
+	__u16		ss;
+
+	__u64		tls_array[3];
+} __packed;
+
 struct kstate_image_mm_struct {
 	struct kstate_object_header hdr;
 
diff --git a/include/linux/kstate.h b/include/linux/kstate.h
index c4b55b6..95898ec 100644
--- a/include/linux/kstate.h
+++ b/include/linux/kstate.h
@@ -67,7 +67,7 @@ int kstate_collect_all_file(struct kstate_context *ctx);
 int kstate_dump_all_file(struct kstate_context *ctx);
 int kstate_restore_file(struct kstate_context *ctx, kstate_ref_t *ref);
 
-#if defined(CONFIG_X86_32)
+#if defined(CONFIG_X86_32) || defined(CONFIG_X86_64)
 extern const __u32 kstate_kernel_arch;
 int kstate_arch_check_image_header(struct kstate_image_header *i);
 
diff --git a/kernel/kstate/Makefile b/kernel/kstate/Makefile
index ca19a22..0678fc9 100644
--- a/kernel/kstate/Makefile
+++ b/kernel/kstate/Makefile
@@ -7,3 +7,4 @@ kstate-y += kstate-mm.o
 kstate-y += kstate-object.o
 kstate-y += kstate-task.o
 kstate-$(CONFIG_X86_32) += kstate-x86_32.o
+kstate-$(CONFIG_X86_64) += kstate-x86_64.o
diff --git a/kernel/kstate/kstate-x86_64.c b/kernel/kstate/kstate-x86_64.c
new file mode 100644
index 0000000..0d85704
--- /dev/null
+++ b/kernel/kstate/kstate-x86_64.c
@@ -0,0 +1,336 @@
+/* Copyright (C) 2000-2009 Parallels Holdings, Ltd. */
+#include <linux/sched.h>
+
+#include <linux/kstate.h>
+#include <linux/kstate-image.h>
+
+const __u32 kstate_kernel_arch = KSTATE_ARCH_X86_64;
+
+int kstate_arch_check_image_header(struct kstate_image_header *i)
+{
+	if (i->kernel_arch == cpu_to_le32(KSTATE_ARCH_X86_64))
+		return 0;
+	return -EINVAL;
+}
+
+__u32 kstate_task_struct_arch(struct task_struct *tsk)
+{
+	return KSTATE_ARCH_X86_64;
+}
+
+static int check_rflags(__u64 rflags)
+{
+	rflags &= ~X86_EFLAGS_CF;
+	rflags &= ~X86_EFLAGS_PF;
+	rflags &= ~X86_EFLAGS_AF;
+	rflags &= ~X86_EFLAGS_ZF;
+	rflags &= ~X86_EFLAGS_SF;
+	rflags &= ~X86_EFLAGS_TF;
+	rflags &= ~X86_EFLAGS_DF;
+	rflags &= ~X86_EFLAGS_OF;
+	rflags &= ~X86_EFLAGS_NT;
+	rflags &= ~X86_EFLAGS_AC;
+	rflags &= ~X86_EFLAGS_ID;
+	if (rflags != (X86_EFLAGS_IF|0x2)) {
+		pr_debug("%s: rflags %016llx\n", __func__, (unsigned long long)rflags);
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int check_segment64(__u16 seg)
+{
+	switch (seg) {
+	case KSTATE_SEG_NULL:
+	case KSTATE_SEG_USER64_CS:
+	case KSTATE_SEG_USER64_DS:
+		return 0;
+	}
+	if (seg & KSTATE_SEG_TLS) {
+		if ((seg & ~KSTATE_SEG_TLS) > GDT_ENTRY_TLS_MAX - GDT_ENTRY_TLS_MIN) {
+			pr_debug("%s: seg %04x, GDT_ENTRY_TLS_MIN %u, GDT_ENTRY_TLS_MAX %u\n", __func__, seg, GDT_ENTRY_TLS_MIN, GDT_ENTRY_TLS_MAX);
+			return -EINVAL;
+		}
+		return 0;
+	}
+	if (seg & KSTATE_SEG_LDT) {
+		if ((seg & ~KSTATE_SEG_LDT) > 0x1fff) {
+			pr_debug("%s: seg %04x\n", __func__, seg);
+			return -EINVAL;
+		}
+		return 0;
+	}
+	pr_debug("%s: seg %04x\n", __func__, seg);
+	return -EINVAL;
+}
+
+static int check_tls(struct desc_struct *desc)
+{
+	if (desc->l != 0 || desc->s != 1 || desc->dpl != 3)
+		return -EINVAL;
+	return 0;
+}
+
+static int check_image_task_struct_x86_64(struct kstate_image_task_struct *tsk_i)
+{
+	struct kstate_image_task_struct_x86_64 *i = (void *)(tsk_i + 1);
+	int rv;
+
+	if (tsk_i->hdr.obj_len < sizeof(*tsk_i) + sizeof(*i))
+		return -EINVAL;
+
+	rv = check_rflags(i->rflags);
+	if (rv < 0)
+		return rv;
+
+	if (i->fs >= TASK_SIZE_MAX)
+		return -EINVAL;
+	if (i->gs >= TASK_SIZE_MAX)
+		return -EINVAL;
+
+	if (i->cs == KSTATE_SEG_NULL)
+		return -EINVAL;
+	rv = check_segment64(i->cs);
+	if (rv < 0)
+		return rv;
+	rv = check_segment64(i->ds);
+	if (rv < 0)
+		return rv;
+	rv = check_segment64(i->es);
+	if (rv < 0)
+		return rv;
+	rv = check_segment64(i->fsindex);
+	if (rv < 0)
+		return rv;
+	rv = check_segment64(i->gsindex);
+	if (rv < 0)
+		return rv;
+	rv = check_segment64(i->ss);
+	if (rv < 0)
+		return rv;
+
+	if (i->tls_array[0]) {
+		rv = check_tls((struct desc_struct *)&i->tls_array[0]);
+		if (rv < 0)
+			return rv;
+	}
+	if (i->tls_array[1]) {
+		rv = check_tls((struct desc_struct *)&i->tls_array[1]);
+		if (rv < 0)
+			return rv;
+	}
+	if (i->tls_array[2]) {
+		rv = check_tls((struct desc_struct *)&i->tls_array[2]);
+		if (rv < 0)
+			return rv;
+	}
+
+	return 0;
+}
+
+int kstate_arch_check_image_task_struct(struct kstate_image_task_struct *i)
+{
+	if (i->tsk_arch == KSTATE_ARCH_X86_64)
+		return check_image_task_struct_x86_64(i);
+	return -EINVAL;
+}
+
+unsigned int kstate_arch_len_task_struct(struct task_struct *tsk)
+{
+	return sizeof(struct kstate_image_task_struct_x86_64);
+}
+
+int kstate_arch_check_task_struct(struct task_struct *tsk)
+{
+	struct restart_block *rb;
+
+#ifdef CONFIG_COMPAT
+	if (test_tsk_thread_flag(tsk, TIF_IA32)) {
+		WARN_ON(1);
+		return -EINVAL;
+	}
+#endif
+	if (test_tsk_thread_flag(tsk, TIF_DEBUG)) {
+		WARN_ON(1);
+		return -EINVAL;
+	}
+	if (tsk->thread.xstate) {
+		WARN_ON(1);
+		return -EINVAL;
+	}
+	rb = &task_thread_info(tsk)->restart_block;
+	if (rb->fn != current_thread_info()->restart_block.fn) {
+		WARN(1, "rb->fn = %pF\n", rb->fn);
+		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 seg)
+{
+	if (seg == 0)
+		return KSTATE_SEG_NULL;
+	BUG_ON((seg & 3) != 3);
+	if (seg & 4)
+		return KSTATE_SEG_LDT | (seg >> 3);
+
+	if (seg == __USER_CS)
+		return KSTATE_SEG_USER64_CS;
+	if (seg == __USER_DS)
+		return KSTATE_SEG_USER64_DS;
+
+	if (GDT_ENTRY_TLS_MIN <= (seg >> 3) && (seg >> 3) <= GDT_ENTRY_TLS_MAX)
+		return KSTATE_SEG_TLS | ((seg >> 3) - GDT_ENTRY_TLS_MIN);
+	BUG();
+}
+
+static u16 decode_segment(__u16 seg)
+{
+	if (seg == KSTATE_SEG_NULL)
+		return 0;
+	if (seg == KSTATE_SEG_USER64_CS)
+		return __USER_CS;
+	if (seg == KSTATE_SEG_USER64_DS)
+		return __USER_DS;
+
+	BUILD_BUG_ON(GDT_ENTRY_TLS_MAX - GDT_ENTRY_TLS_MIN + 1 != 3);
+	if ((seg & KSTATE_SEG_TLS) == KSTATE_SEG_TLS) {
+		seg &= ~KSTATE_SEG_TLS;
+		if (seg <= GDT_ENTRY_TLS_MAX - GDT_ENTRY_TLS_MIN)
+			return ((GDT_ENTRY_TLS_MIN + seg) << 3) | 3;
+	}
+	if ((seg & KSTATE_SEG_LDT) == KSTATE_SEG_LDT) {
+		seg &= ~KSTATE_SEG_LDT;
+		return (seg << 3) | 7;
+	}
+	BUG();
+}
+
+static int dump_task_struct_x86_64(struct kstate_context *ctx, struct task_struct *tsk, void *arch_i)
+{
+	struct kstate_image_task_struct_x86_64 *i = arch_i;
+	struct pt_regs *regs = task_pt_regs(tsk);
+
+	i->r15 = regs->r15;
+	i->r14 = regs->r14;
+	i->r13 = regs->r13;
+	i->r12 = regs->r12;
+	i->rbp = regs->bp;
+	i->rbx = regs->bx;
+	i->r11 = regs->r11;
+	i->r10 = regs->r10;
+	i->r9 = regs->r9;
+	i->r8 = regs->r8;
+	i->rax = regs->ax;
+	i->rcx = regs->cx;
+	i->rdx = regs->dx;
+	i->rsi = regs->si;
+	i->rdi = regs->di;
+	i->orig_rax = regs->orig_ax;
+	i->rip = regs->ip;
+	i->rflags = regs->flags;
+	i->rsp = regs->sp;
+
+	i->fs = tsk->thread.fs;
+	i->gs = tsk->thread.gs;
+	i->cs = encode_segment(regs->cs);
+	i->ds = encode_segment(tsk->thread.ds);
+	i->es = encode_segment(tsk->thread.es);
+	i->fsindex = encode_segment(tsk->thread.fsindex);
+	i->gsindex = encode_segment(tsk->thread.gsindex);
+	i->ss = encode_segment(regs->ss);
+
+	BUILD_BUG_ON(sizeof(tsk->thread.tls_array[0]) != 8);
+	BUILD_BUG_ON(sizeof(tsk->thread.tls_array) != 3 * 8);
+	memcpy(i->tls_array, tsk->thread.tls_array, sizeof(i->tls_array));
+
+	return 0;
+}
+
+int kstate_arch_dump_task_struct(struct kstate_context *ctx, struct task_struct *tsk, void *arch_i)
+{
+	return dump_task_struct_x86_64(ctx, tsk, arch_i);
+}
+
+static int restore_task_struct_x86_64(struct task_struct *tsk, struct kstate_image_task_struct_x86_64 *i)
+{
+	struct pt_regs *regs = task_pt_regs(tsk);
+
+	tsk->thread.sp = (unsigned long)regs;
+	tsk->thread.sp0 = (unsigned long)(regs + 1);
+
+	regs->r15 = i->r15;
+	regs->r14 = i->r14;
+	regs->r13 = i->r13;
+	regs->r12 = i->r12;
+	regs->bp = i->rbp;
+	regs->bx = i->rbx;
+	regs->r11 = i->r11;
+	regs->r10 = i->r10;
+	regs->r9 = i->r9;
+	regs->r8 = i->r8;
+	regs->ax = i->rax;
+	regs->cx = i->rcx;
+	regs->dx = i->rdx;
+	regs->si = i->rsi;
+	regs->di = i->rdi;
+	regs->orig_ax = i->orig_rax;
+	regs->ip = i->rip;
+	regs->flags = i->rflags;
+	regs->sp = i->rsp;
+	tsk->thread.usersp = regs->sp;
+
+	tsk->thread.fs = i->fs;
+	tsk->thread.gs = i->gs;
+	regs->cs = decode_segment(i->cs);
+	tsk->thread.ds = decode_segment(i->ds);
+	tsk->thread.es = decode_segment(i->es);
+	tsk->thread.fsindex = decode_segment(i->fsindex);
+	tsk->thread.gsindex = decode_segment(i->gsindex);
+	regs->ss = decode_segment(i->ss);
+
+	memcpy(tsk->thread.tls_array, i->tls_array, sizeof(i->tls_array));
+
+	set_tsk_thread_flag(tsk, TIF_FORK);
+	return 0;
+}
+
+int kstate_arch_restore_task_struct(struct task_struct *tsk, struct kstate_image_task_struct *i)
+{
+	if (i->tsk_arch == KSTATE_ARCH_X86_64) {
+		return restore_task_struct_x86_64(tsk, (void *)(i + 1));
+	}
+	BUG();
+}
+
+int kstate_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;
+	}
+	mutex_unlock(&mm->context.lock);
+	return 0;
+}
+
+unsigned int kstate_arch_len_mm_struct(struct mm_struct *mm)
+{
+	return 0;
+}
+
+int kstate_arch_dump_mm_struct(struct kstate_context *ctx, struct mm_struct *mm, void *arch_i)
+{
+	return 0;
+}
-- 
1.5.6.5