c/r: extend arch_setup_additional_pages()
Subsystems (25)
PATCH 1/19 c/r: extend arch_setup_additional_pages()
From: Alexey Dobriyan <[email protected]>
Add "start" argument, to request to map vDSO to a specific place, and fail the operation if not.
This is useful for restart(2) to ensure that memory layout is restore exactly as needed.
Changelog[v19]:
- [serge hallyn] Fix potential use-before-set ret
Changelog[v2]:
- [ntl] powerpc: vdso build fix (ckpt-v17)
--- arch/powerpc/include/asm/elf.h | 1 + arch/powerpc/kernel/vdso.c | 13 ++++++++++++- arch/s390/include/asm/elf.h | 2 +- arch/s390/kernel/vdso.c | 13 ++++++++++++- arch/sh/include/asm/elf.h | 1 + arch/sh/kernel/vsyscall/vsyscall.c | 2 +- arch/x86/include/asm/elf.h | 3 ++- arch/x86/vdso/vdso32-setup.c | 9 +++++++-- arch/x86/vdso/vma.c | 11 ++++++++--- fs/binfmt_elf.c | 2 +- 10 files changed, 46 insertions(+), 11 deletions(-)
arch/powerpc/include/asm/elf.h +1 -0
@@ -266,6 +266,7 @@ extern int ucache_bsize;#define ARCH_HAS_SETUP_ADDITIONAL_PAGES struct linux_binprm ;extern int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp);#define VDSO_AUX_ENT (a,b) NEW_AUX_ENT(a,b);
arch/powerpc/kernel/vdso.c +12 -1
@@ -188,7 +188,8 @@ static void dump_vdso_pages(struct vm_area_struct * vma)* This is called from binfmt_elf, we create the special vma for the * vDSO and insert it into the mm struct tree */ -int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) +int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp) {struct mm_struct *mm = current->mm;struct page **vdso_pagelist;
@@ -220,6 +221,10 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) vdso_base =VDSO32_MBASE ;#endif +/* in case restart(2) mandates a specific location */ +if (start) + vdso_base = start; + current->mm->context.vdso_base =0 ;/* vDSO has a problem and was disabled, just don't "enable" it for the
@@ -249,6 +254,12 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)/* Add required alignment. */ vdso_base =ALIGN (vdso_base,VDSO_ALIGNMENT ); +/* for restart(2), double check that we got we asked for */ +if (start && vdso_base != start) { + rc = -EBUSY ; + goto fail_mmapsem; + } +/* * Put vDSO base into mm struct. We need to do this before calling * install_special_mapping or the perf counter mmap tracking code
arch/s390/include/asm/elf.h +1 -1
@@ -216,6 +216,6 @@ do { \struct linux_binprm ;#define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1 -int arch_setup_additional_pages (struct linux_binprm *,int ); +int arch_setup_additional_pages (struct linux_binprm *,unsigned long ,int );#endif
arch/s390/kernel/vdso.c +12 -1
@@ -187,7 +187,8 @@ static void vdso_init_cr5(void)* This is called from binfmt_elf, we create the special vma for the * vDSO and insert it into the mm struct tree */ -int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) +int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp) {struct mm_struct *mm = current->mm;struct page **vdso_pagelist;
@@ -218,6 +219,10 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) vdso_pages = vdso32_pages;#endif +/* in case restart(2) mandates a specific location */ +if (start) + vdso_base = start; +/* * vDSO has a problem and was disabled, just don't "enable" it for * the process
@@ -240,6 +245,12 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp) goto out_up; } +/* for restart(2), double check that we got we asked for */ +if (start && vdso_base != start) { + rc = -EINVAL ; + goto out_up; + } +/* * Put vDSO base into mm struct. We need to do this before calling * install_special_mapping or the perf counter mmap tracking code
arch/sh/include/asm/elf.h +1 -0
@@ -190,6 +190,7 @@ do { \#define ARCH_HAS_SETUP_ADDITIONAL_PAGES struct linux_binprm ;extern int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp);extern unsigned int vdso_enabled;
arch/sh/kernel/vsyscall/vsyscall.c +1 -1
@@ -58,7 +58,7 @@ int __init vsyscall_init(void) }/* Setup a VMA at program startup for the vsyscall page */ -int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) +int arch_setup_additional_pages (struct linux_binprm *bprm,unsigned long start,int uses_interp) {struct mm_struct *mm = current->mm;unsigned long addr;
arch/x86/include/asm/elf.h +2 -1
@@ -312,9 +312,10 @@ struct linux_binprm;#define ARCH_HAS_SETUP_ADDITIONAL_PAGES 1extern int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp); -extern int syscall32_setup_pages (struct linux_binprm *,int exstack); +extern int syscall32_setup_pages (struct linux_binprm *,unsigned long start,int exstack);#define compat_arch_setup_additional_pages syscall32_setup_pagesextern unsigned long arch_randomize_brk (struct mm_struct *mm);
arch/x86/vdso/vdso32-setup.c +7 -2
@@ -310,7 +310,8 @@ int __init sysenter_setup(void) }/* Setup a VMA at program startup for the vsyscall page */ -int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) +int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp) {struct mm_struct *mm = current->mm;unsigned long addr;
@@ -331,13 +332,17 @@ int arch_setup_additional_pages(struct linux_binprm *bprm, int uses_interp)if (compat) addr =VDSO_HIGH_BASE ;else { - addr =get_unmapped_area (NULL ,0 ,PAGE_SIZE ,0 ,0 ); + addr =get_unmapped_area (NULL , start,PAGE_SIZE ,0 ,0 );if (IS_ERR_VALUE (addr)) { ret = addr; goto up_fail; } } +/* for restart(2), double check that we got we asked for */ +if (start && addr != start) + goto up_fail; + current->mm->context.vdso = (void *)addr;if (compat_uses_vma || !compat) {
arch/x86/vdso/vma.c +8 -3
@@ -101,23 +101,28 @@ static unsigned long vdso_addr(unsigned long start, unsigned len)/* Setup a VMA at program startup for the vsyscall page. Not called for compat tasks */ -int arch_setup_additional_pages (struct linux_binprm *bprm,int uses_interp) +int arch_setup_additional_pages (struct linux_binprm *bprm, +unsigned long start,int uses_interp) {struct mm_struct *mm = current->mm;unsigned long addr; -int ret; +int ret = -EINVAL ;if (!vdso_enabled)return 0 ;down_write (&mm->mmap_sem); - addr =vdso_addr (mm->start_stack, vdso_size); + addr = start ? :vdso_addr (mm->start_stack, vdso_size); addr =get_unmapped_area (NULL , addr, vdso_size,0 ,0 );if (IS_ERR_VALUE (addr)) { ret = addr; goto up_fail; } +/* for restart(2), double check that we got we asked for */ +if (start && addr != start) + goto up_fail; + current->mm->context.vdso = (void *)addr; ret = install_special_mapping(mm, addr, vdso_size,
fs/binfmt_elf.c +1 -1
@@ -923,7 +923,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)set_binfmt (&elf_format);#ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES - retval =arch_setup_additional_pages (bprm, !!elf_interpreter); + retval =arch_setup_additional_pages (bprm,0 , !!elf_interpreter);if (retval <0 ) {send_sig (SIGKILL , current,0 ); goto out;
Signature · 1 line
1.7.2.2
PATCH 3/19 cgroup freezer: Add CHECKPOINTING state to safeguard container checkpoint
From: Matt Helsley <[email protected]>
The CHECKPOINTING state prevents userspace from unfreezing tasks until sys_checkpoint() is finished. When doing container checkpoint userspace will do:
echo FROZEN > /cgroups/my_container/freezer.state ... rc = sys_checkpoint( <pid of container root> );
To ensure a consistent checkpoint image userspace should not be allowed to thaw the cgroup (echo THAWED > /cgroups/my_container/freezer.state) during checkpoint.
"CHECKPOINTING" can only be set on a "FROZEN" cgroup using the checkpoint system call. Once in the "CHECKPOINTING" state, the cgroup may not leave until the checkpoint system call is finished and ready to return. Then the freezer state returns to "FROZEN". Writing any new state to freezer.state while checkpointing will return EBUSY. These semantics ensure that userspace cannot unfreeze the cgroup midway through the checkpoint system call.
The cgroup_freezer_begin_checkpoint() and cgroup_freezer_end_checkpoint() make relatively few assumptions about the task that is passed in. However the way they are called in do_checkpoint() assumes that the root of the container is in the same freezer cgroup as all the other tasks that will be checkpointed.
Notes:
As a side-effect this prevents the multiple tasks from entering the CHECKPOINTING state simultaneously. All but one will get -EBUSY.
--- Documentation/cgroups/freezer-subsystem.txt | 10 ++ include/linux/freezer.h | 8 ++ kernel/cgroup_freezer.c | 129 ++++++++++++++++++++++++++- 3 files changed, 144 insertions(+), 3 deletions(-)
Documentation/cgroups/freezer-subsystem.txt +10 -0
@@ -100,3 +100,13 @@ things happens: and returns EINVAL) 3) The tasks that blocked the cgroup from entering the "FROZEN" state disappear from the cgroup's set of tasks. + +When the cgroup freezer is used to guard container checkpoint operations the +freezer.state may be "CHECKPOINTING". "CHECKPOINTING" can only be set on a +"FROZEN" cgroup using the checkpoint system call. Once in the "CHECKPOINTING" +state, the cgroup may not leave until the checkpoint system call returns the +freezer state to "FROZEN". Writing any new state to freezer.state while +checkpointing will return EBUSY. These semantics ensure that userspace cannot +unfreeze the cgroup midway through the checkpoint system call. Note that, +unlike "FROZEN" and "FREEZING", there is no corresponding "CHECKPOINTED" +state.
include/linux/freezer.h +8 -0
@@ -65,11 +65,19 @@ extern void cancel_freezing(struct task_struct *p);#ifdef CONFIG_CGROUP_FREEZER extern int cgroup_freezing_or_frozen (struct task_struct *task); +extern int in_same_cgroup_freezer (struct task_struct *p,struct task_struct *q); +extern int cgroup_freezer_begin_checkpoint (struct task_struct *task); +extern void cgroup_freezer_end_checkpoint (struct task_struct *task);#else /* !CONFIG_CGROUP_FREEZER */ static inline int cgroup_freezing_or_frozen (struct task_struct *task) {return 0 ; } +static inline int in_same_cgroup_freezer (struct task_struct *p, +struct task_struct *q) +{ +return 0 ; +}#endif /* !CONFIG_CGROUP_FREEZER */ /*
kernel/cgroup_freezer.c +126 -3
163 lines not on this page · raw message
Signature · 1 line
1.7.2.2
Re: [PATCH 03/19] cgroup freezer: Add CHECKPOINTING state to safeguard container checkpoint
DS> Signed-off-by: Oren Laadan <[email protected]> DS> Signed-off-by: Matt Helsley <[email protected]> DS> Cc: Cedric Le Goater <[email protected]> DS> Cc: Paul Menage <[email protected]>
DS> Cc: Li Zefan <[email protected]>
DS> Cc: Rafael J. Wysocki <[email protected]>
DS> Cc: [email protected]
My apologies to the above-mentioned people. I didn't intend to send it out at all.
Signature · 3 lines
Dan Smith IBM Linux Technology Center email: [email protected]
PATCH 4/19 Make file_pos_read/write() public and export kernel_write()
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
These three are used in a subsequent patch to allow the kernel c/r code to call vfs_read/write() to read and write data to and from the checkpoint image.
This patch makes the following changes:
1) Move kernel_write() from fs/splice.c to fs/exec.c to be near kernel_read()
2) Make kernel_read/write() iterate if they face partial reads or writes, and retry if they face -EAGAIN.
3) Adjust prototypes of kernel_read/write() to use size_t and ssize_t
4) Move file_pos_read/write() to include/linux/fs.h
Changelog [ckpt-v21]
- Introduce kernel_write(), fix kernel_read()
--- fs/exec.c | 69 ++++++++++++++++++++++++++++++++++++++++++++++++---- fs/read_write.c | 10 ------- fs/splice.c | 17 +------------ include/linux/fs.h | 13 +++++++++- 4 files changed, 77 insertions(+), 32 deletions(-)
fs/exec.c +64 -5
@@ -720,23 +720,82 @@ exit: }EXPORT_SYMBOL (open_exec); -int kernel_read (struct file *file,loff_t offset, -char *addr,unsigned long count) +static ssize_t _kernel_read (struct file *file,loff_t offset, +char __user *ubuf,size_t count) { -mm_segment_t old_fs; +ssize_t nread; +size_t nleft;loff_t pos = offset; -int result; + +for (nleft = count; nleft; nleft -= nread) { + nread =vfs_read (file, ubuf, nleft, &pos); +if (nread <=0 ) { +if (nread == -EAGAIN ) { + nread =0 ; +continue ; + }else if (nread ==0 ) +break ; +else +return nread; + } + ubuf += nread; + } +return count - nleft; +} + +ssize_t kernel_read (struct file *file,loff_t offset, +char *addr,size_t count) +{ +mm_segment_t old_fs; +ssize_t result; old_fs =get_fs ();set_fs (get_ds ());/* The cast to a user pointer is valid due to the set_fs() */ - result =vfs_read (file, (void __user *)addr, count, &pos); + result =_kernel_read (file, offset, (void __user *)addr, count);set_fs (old_fs);return result; }EXPORT_SYMBOL (kernel_read); +static ssize_t _kernel_write (struct file *file,loff_t offset, +const char __user *ubuf,size_t count) +{ +ssize_t nwrite; +size_t nleft; +loff_t pos = offset; + +for (nleft = count; nleft; nleft -= nwrite) { + nwrite =vfs_write (file, ubuf, nleft, &pos); +if (nwrite <0 ) { +if (nwrite == -EAGAIN ) { + nwrite =0 ; +continue ; + }else +return nwrite; + } + ubuf += nwrite; + } +return count - nleft; +} + +ssize_t kernel_write (struct file *file,loff_t offset, +const char *addr,size_t count) +{ +mm_segment_t old_fs; +ssize_t result; + + old_fs =get_fs (); +set_fs (get_ds ()); +/* The cast to a user pointer is valid due to the set_fs() */ + result =_kernel_write (file, offset, (void __user *)addr, count); +set_fs (old_fs); +return result; +} + +EXPORT_SYMBOL (kernel_write); +static int exec_mmap (struct mm_struct *mm) {struct task_struct *tsk;
fs/read_write.c +0 -10
@@ -395,16 +395,6 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_EXPORT_SYMBOL (vfs_write); -static inline loff_t file_pos_read (struct file *file) -{ -return file->f_pos; -} - -static inline void file_pos_write (struct file *file,loff_t pos) -{ - file->f_pos = pos; -} - SYSCALL_DEFINE3(read, unsigned int, fd, char __user *, buf, size_t, count) {struct file *file;
fs/splice.c +1 -16
@@ -562,21 +562,6 @@ static ssize_t kernel_readv(struct file *file, const struct iovec *vec,return res; } -static ssize_t kernel_write (struct file *file,const char *buf,size_t count, -loff_t pos) -{ -mm_segment_t old_fs; -ssize_t res; - - old_fs =get_fs (); -set_fs (get_ds ()); -/* The cast to a user pointer is valid due to the set_fs() */ - res =vfs_write (file, (const char __user *)buf, count, &pos); -set_fs (old_fs); - -return res; -} -ssize_t default_file_splice_read (struct file *in,loff_t *ppos,struct pipe_inode_info *pipe,size_t len,unsigned int flags)
@@ -1049,7 +1034,7 @@ static int write_pipe_buf(struct pipe_inode_info *pipe, struct pipe_buffer *buf,return ret; data = buf->ops->map (pipe, buf,0 ); - ret =kernel_write (sd->u.file, data + buf->offset, sd->len, sd->pos); + ret =kernel_write (sd->u.file, sd->pos, data + buf->offset, sd->len); buf->ops->unmap (pipe, buf, data);return ret;
include/linux/fs.h +12 -1
@@ -1581,6 +1581,16 @@ ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,struct iovec *fast_pointer, struct iovec **ret_pointer); +static inline loff_t file_pos_read (struct file *file) +{ +return file->f_pos; +} + +static inline void file_pos_write (struct file *file,loff_t pos) +{ + file->f_pos = pos; +} +extern ssize_t vfs_read (struct file *,char __user *,size_t ,loff_t *);extern ssize_t vfs_write (struct file *,const char __user *,size_t ,loff_t *); extern ssize_t vfs_readv(struct file *, const struct iovec __user *,
@@ -2186,7 +2196,8 @@ extern struct file *do_filp_open(int dfd, const char *pathname, int open_flag, int mode, int acc_mode);extern int may_open (struct path *,int ,int ); -extern int kernel_read (struct file *,loff_t ,char *,unsigned long ); +extern ssize_t kernel_read (struct file *,loff_t ,char *,size_t ); +extern ssize_t kernel_write (struct file *,loff_t ,const char *,size_t );extern struct file *open_exec (const char *);/* fs/dcache.c -- generic fs support functions */
Signature · 1 line
1.7.2.2
Re: [PATCH 04/19] Make file_pos_read/write() public and export kernel_write()
DS> Cc: [email protected]
Sorry about this, I didn't meant to git-send-email this set.
Signature · 3 lines
Dan Smith IBM Linux Technology Center email: [email protected]
A message that is not in the archive (sent off-list or not yet received): 1292343307-7870-1-git-send-email-danms-r/[email protected]
PATCH 6/19 c/r: create syscalls: sys_checkpoint, sys_restart
From: Oren Laadan <[email protected]>
Create trivial sys_checkpoint and sys_restore system calls. They will enable to checkpoint and restart an entire container, to and from a checkpoint image file descriptor.
The syscalls take a pid, a file descriptor (for the image file) and flags as arguments. The pid identifies the top-most (root) task in the process tree, e.g. the container init: for sys_checkpoint the first argument identifies the pid of the target container/subtree; for sys_restart it will identify the pid of restarting root task.
A checkpoint, much like a process coredump, dumps the state of multiple processes at once, including the state of the container. The checkpoint image is written to (and read from) the file descriptor directly from the kernel. This way the data is generated and then pushed out naturally as resources and tasks are scanned to save their state. This is the approach taken by, e.g., Zap and OpenVZ.
By using a return value and not a file descriptor, we can distinguish between a return from checkpoint, a return from restart (in case of a checkpoint that includes self, i.e. a task checkpointing its own container, or itself), and an error condition, in a manner analogous to a fork() call.
We don't use copy_from_user()/copy_to_user() because it requires holding the entire image in user space, and does not make sense for restart. Also, we don't use a pipe, pseudo-fs file and the like, because they work by generating data on demand as the user pulls it (unless the entire image is buffered in the kernel) and would require more complex logic. They also would significantly complicate checkpoint that includes self.
Changelog[v21-rc3]:
- Reorganize code:move checkpoint/* to kernel/checkpoint/*
Changelog[v19-rc1]:
- Add 'int logfd' to prototype of sys_{checkpoint,restart}
Changelog[v18]:
- [John Dykstra] Fix no-dot-config-targets pattern in linux/Makefile
Changelog[v17]:
- Move checkpoint closer to namespaces (kconfig)
- Kill "Enable" in c/r config option
Changelog[v16]:
- Change sys_restart() first argument to be 'pid_t pid'
Changelog[v14]:
- Change CONFIG_CHEKCPOINT_RESTART to CONFIG_CHECKPOINT (Ingo)
- Remove line 'def_bool n' (default is already 'n')
- Add CHECKPOINT_SUPPORT in Kconfig (Nathan Lynch)
Changelog[v5]:
- Config is 'def_bool n' by default
--- Makefile | 2 +- arch/x86/Kconfig | 4 +++ arch/x86/include/asm/unistd_32.h | 4 ++- arch/x86/kernel/syscall_table_32.S | 2 + include/linux/syscalls.h | 4 +++ init/Kconfig | 2 + kernel/Makefile | 1 + kernel/checkpoint/Kconfig | 14 +++++++++++ kernel/checkpoint/Makefile | 5 ++++ kernel/checkpoint/sys.c | 45 ++++++++++++++++++++++++++++++++++++ kernel/sys_ni.c | 4 +++ 11 files changed, 85 insertions(+), 2 deletions(-) create mode 100644 kernel/checkpoint/Kconfig create mode 100644 kernel/checkpoint/Makefile create mode 100644 kernel/checkpoint/sys.c
Makefile +1 -1
@@ -421,7 +421,7 @@ endif no-dot-config-targets := clean mrproper distclean \ cscope TAGS tags help %docs check% coccicheck \ - include/linux/version.h headers_% \ + checkstack include/linux/version.h headers_% \ kernelversion %src-pkg config-targets := 0
arch/x86/Kconfig +4 -0
@@ -101,6 +101,10 @@ config STACKTRACE_SUPPORT config HAVE_LATENCYTOP_SUPPORT def_bool y +config CHECKPOINT_SUPPORT + bool + default y if X86_32 + config MMU def_bool y
arch/x86/include/asm/unistd_32.h +3 -1
@@ -346,10 +346,12 @@#define __NR_fanotify_init 338#define __NR_fanotify_mark 339#define __NR_prlimit64 340 +#define __NR_checkpoint 341 +#define __NR_restart 342#ifdef __KERNEL__ -#define NR_syscalls 341 +#define NR_syscalls 343#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
arch/x86/kernel/syscall_table_32.S +2 -0
@@ -340,3 +340,5 @@ ENTRY(sys_call_table) .long sys_fanotify_init .long sys_fanotify_mark .long sys_prlimit64 /* 340 */ + .long ptregs_checkpoint + .long ptregs_restart
include/linux/syscalls.h +4 -0
@@ -820,6 +820,10 @@ asmlinkage long sys_fanotify_init(unsigned int flags, unsigned int event_f_flagsasmlinkage long sys_fanotify_mark (int fanotify_fd,unsigned int flags,u64 mask,int fd,const char __user *pathname); +asmlinkage long sys_checkpoint (pid_t pid,int fd,unsigned long flags, +int logfd); +asmlinkage long sys_restart (pid_t pid,int fd,unsigned long flags, +int logfd);int kernel_execve (const char *filename,const char *const argv[],const char *const envp[]);
init/Kconfig +2 -0
@@ -780,6 +780,8 @@ config RELAY If unsure, say N. +source "kernel/checkpoint/Kconfig" + config BLK_DEV_INITRD bool "Initial RAM filesystem and RAM disk (initramfs/initrd) support" depends on BROKEN || !FRV
kernel/Makefile +1 -0
@@ -106,6 +106,7 @@ obj-$(CONFIG_PERF_EVENTS) += perf_event.o obj-$(CONFIG_HAVE_HW_BREAKPOINT) += hw_breakpoint.o obj-$(CONFIG_USER_RETURN_NOTIFIER) += user-return-notifier.o obj-$(CONFIG_PADATA) += padata.o +obj-$(CONFIG_CHECKPOINT) += checkpoint/ ifneq ($(CONFIG_SCHED_OMIT_FRAME_POINTER),y) # According to Alan Modra <[email protected]>, the -fno-omit-frame-pointer is
kernel/checkpoint/Kconfig new file +14 -0
@@ -0,0 +1,14 @@ +# Architectures should define CHECKPOINT_SUPPORT when they have +# implemented the hooks for processor state etc. needed by the +# core checkpoint/restart code. + +config CHECKPOINT + bool "Checkpoint/restart (EXPERIMENTAL)" + depends on CHECKPOINT_SUPPORT && EXPERIMENTAL + help + Application checkpoint/restart is the ability to save the + state of a running application so that it can later resume + its execution from the time at which it was checkpointed. + + Turning this option on will enable checkpoint and restart + functionality in the kernel.
kernel/checkpoint/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# +# Makefile for linux checkpoint/restart. +# + +obj-$(CONFIG_CHECKPOINT) += sys.o
kernel/checkpoint/sys.c new file +45 -0
45 lines not on this page · raw message
kernel/sys_ni.c +4 -0
@@ -186,3 +186,7 @@ cond_syscall(sys_perf_event_open);/* fanotify! */ cond_syscall (sys_fanotify_init);cond_syscall (sys_fanotify_mark); + +/* checkpoint/restart */ +cond_syscall (sys_checkpoint); +cond_syscall (sys_restart);
Signature · 1 line
1.7.2.2
PATCH 5/19 c/r: documentation
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
Covers application checkpoint/restart, overall design, interfaces, usage, shared objects, and and checkpoint image format.
Changelog[v19-rc1]:
- Update documentation and examples for new syscalls API
- [Liu Alexander] Fix typos
- [Serge Hallyn] Update checkpoint image format
Changelog[v16]:
- Update documentation
- Unify into readme.txt and usage.txt
Changelog[v14]:
- Discard the 'h.parent' field
- New image format (shared objects appear before they are referenced unless they are compound)
Changelog[v8]:
- Split into multiple files in Documentation/checkpoint/...
- Extend documentation, fix typos and comments from feedback
--- Documentation/checkpoint/checkpoint.c | 38 +++ Documentation/checkpoint/readme.txt | 370 ++++++++++++++++++++++++++++ Documentation/checkpoint/self_checkpoint.c | 69 +++++ Documentation/checkpoint/self_restart.c | 40 +++ Documentation/checkpoint/usage.txt | 247 +++++++++++++++++++ 5 files changed, 764 insertions(+), 0 deletions(-) create mode 100644 Documentation/checkpoint/checkpoint.c create mode 100644 Documentation/checkpoint/readme.txt create mode 100644 Documentation/checkpoint/self_checkpoint.c create mode 100644 Documentation/checkpoint/self_restart.c create mode 100644 Documentation/checkpoint/usage.txt
Documentation/checkpoint/checkpoint.c new file +38 -0
@@ -0,0 +1,38 @@ +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <sys/syscall.h> + +#include <linux/checkpoint.h> + +static inline int checkpoint (pid_t pid,int fd,unsigned long flags) +{ +return syscall (__NR_checkpoint, pid, fd, flags); +} + +int main (int argc,char *argv[]) +{ +pid_t pid; +int ret; + +if (argc !=2 ) { +printf ("usage: ckpt PID\n" ); +exit (1 ); + } + + pid =atoi (argv[1 ]); +if (pid <=0 ) { +printf ("invalid pid\n" ); +exit (1 ); + } + + ret =checkpoint (pid,STDOUT_FILENO ,CHECKPOINT_SUBTREE ); + +if (ret <0 ) +perror ("checkpoint" ); +else +printf ("checkpoint id %d\n" , ret); + +return (ret >0 ?0 :1 ); +}
Documentation/checkpoint/readme.txt new file +370 -0
370 lines not on this page · raw message
Documentation/checkpoint/self_checkpoint.c new file +69 -0
69 lines not on this page · raw message
Documentation/checkpoint/self_restart.c new file +40 -0
@@ -0,0 +1,40 @@ +/* +* self_restart.c: demonstrate self-restart +* +* Copyright (C) 2008 Oren Laadan +* +* This file is subject to the terms and conditions of the GNU General Public +* License. See the file COPYING in the main directory of the Linux +* distribution for more details. +*/ + +#define _GNU_SOURCE/* or _BSD_SOURCE or _SVID_SOURCE */ + +#include <stdio.h> +#include <stdlib.h> +#include <errno.h> +#include <fcntl.h> +#include <unistd.h> +#include <unistd.h> +#include <sys/syscall.h> + +#include <linux/checkpoint.h> + +static inline int restart (pid_t pid,int fd,unsigned long flags) +{ +return syscall (__NR_restart, pid, fd, flags,CHECKPOINT_FD_NONE ); +} + +int main (int argc,char *argv[]) +{ +pid_t pid =getpid (); +int ret; + + ret =restart (pid,STDIN_FILENO ,RESTART_TASKSELF ); +if (ret <0 ) +perror ("restart" ); + +printf ("should not reach here !\n" ); + +return 0 ; +}
Documentation/checkpoint/usage.txt new file +247 -0
247 lines not on this page · raw message
Signature · 1 line
1.7.2.2
Re: [PATCH 05/19] c/r: documentation
DS> Cc: [email protected]
DS> Cc: [email protected]
DS> Cc: [email protected]
DS> Signed-off-by: Dave Hansen <[email protected]>
My apologies to the above mentioned. I didn't mean to git-send-email this set. Please ignore.
Signature · 10 lines
Dan Smith IBM Linux Technology Center email: [email protected] -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Fight unfair telecom policy in Canada: sign http://dissolvethecrtc.ca/ Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 7/19 c/r: basic infrastructure for checkpoint/restart
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
Add those interfaces, as well as helpers needed to easily manage the file format. The code is roughly broken out as follows:
kernel/checkpoint/sys.c - user/kernel data transfer, as well as setup
of the c/r context (a per-checkpoint data structure for housekeeping)
kernel/checkpoint/checkpoint.c - output wrappers and checkpoint handling
kernel/checkpoint/restart.c - input wrappers and restart handling
kernel/checkpoint/process.c - c/r of task data
For now, we can only checkpoint the 'current' task ("self" checkpoint), and the 'pid' argument to the syscall is ignored.
Patches to add the per-architecture support as well as the actual work to do the memory checkpoint follow in subsequent patches.
Changelog[v21]:
- Complain if checkpoint_hdr.h included without CONFIG_CHECKPOINT
- Do not include checkpoint_hdr.h explicitly
- Consolidate ckpt_read/write with kernel_read/write
- Reorganize code:move checkpoint/* to kernel/checkpoint/*
- [Christoffer Dall] Fix trivial bug in ckpt_msg macro
Changelog[v20]:
- Export key symbols to enable c/r from kernel modules
Changelog[v19]:
- [Serge Hallyn] Use ckpt_err() to for bad header values
Changelog[v19-rc3]:
- sys_{checkpoint,restart} to use ptregs prototype
Changelog[v19-rc1]:
- Set ctx->errno in do_ckpt_msg() if needed
- Document prototype of ckpt_write_err in header
- Update prototype of ckpt_read_obj()
- Fix up headers so we can munge them for use by userspace
- [Matt Helsley] Check for empty string for _ckpt_write_err()
- [Matt Helsley] Add cpp definitions for enums
- [Serge Hallyn] Add global section container to image format
- [Matt Helsley] Fix total byte read/write count for large images
- ckpt_read_buf_type() to accept max payload (excludes ckpt_hdr)
- [Serge Hallyn] Define new api for error and debug logging
- Use logfd in sys_{checkpoint,restart}
Changelog[v18]:
- Detect error-headers in input data on restart, and abort.
- Standard format for checkpoint error strings (and documentation)
- [Matt Helsley] Rename headerless struct ckpt_hdr_* to struct ckpt_*
- [Dan Smith] Add an errno validation function
- Add ckpt_read_payload(): read a variable-length object (no header)
- Add ckpt_read_string(): same for strings (ensures null-terminated)
- Add ckpt_read_consume(): consumes next object without processing
Changelog[v17]:
- Fix compilation for architectures that don't support checkpoint
- Save/restore t->{set,clear}_child_tid
- Restart(2) isn't idempotent: must return -EINTR if interrupted
- ckpt_debug does not depend on DYNAMIC_DEBUG, on by default
- Export generic checkpoint headers to userespace
- Fix comment for prototype of sys_restart
- Have ckpt_debug() print global-pid and __LINE__
- Only save and test kernel constants once (in header)
Changelog[v16]:
- Split ctx->flags to ->uflags (user flags) and ->kflags (kernel flags)
- Introduce __ckpt_write_err() and ckpt_write_err() to report errors
- Allow @ptr == NULL to write (or read) header only without payload
- Introduce _ckpt_read_obj_type()
Changelog[v15]:
- Replace header buffer in ckpt_ctx (hbuf,hpos) with kmalloc/kfree()
Changelog[v14]:
- Cleanup interface to get/put hdr buffers
- Merge checkpoint and restart code into a single file (per subsystem)
- Take uts_sem around access to uts->{release,version,machine}
- Embed ckpt_hdr in all ckpt_hdr_...., cleanup read/write helpers
- Define sys_checkpoint(0,...) as asking for a self-checkpoint (Serge)
- Revert use of 'pr_fmt' to avoid tainting whom includes us (Nathan Lynch)
- Explicitly indicate length of UTS fields in header
- Discard field 'h->parent' from ckpt_hdr
Changelog[v12]:
- ckpt_kwrite/ckpt_kread() again use vfs_read(), vfs_write() (safer)
- Split ckpt_write/ckpt_read() to two parts: _ckpt_write/read() helper
- Befriend with sparse : explicit conversion to 'void __user *'
- Redfine 'pr_fmt' instead of using special ckpt_debug()
Changelog[v10]:
- add ckpt_write_buffer(), ckpt_read_buffer() and ckpt_read_buf_type()
- force end-of-string in ckpt_read_string() (fix possible DoS)
Changelog[v9]:
- ckpt_kwrite/ckpt_kread() use file->f_op->write() directly
- Drop ckpt_uwrite/ckpt_uread() since they aren't used anywhere
Changelog[v6]:
- Balance all calls to ckpt_hbuf_get() with matching ckpt_hbuf_put() (although it's not really needed)
Changelog[v5]:
- Rename headers files s/ckpt/checkpoint/
Changelog[v2]:
- Added utsname->{release,version,machine} to checkpoint header
- Pad header structures to 64 bits to ensure compatibility
--- include/linux/Kbuild | 3 + include/linux/checkpoint.h | 202 +++++++++++++++++ include/linux/checkpoint_hdr.h | 135 +++++++++++ include/linux/checkpoint_types.h | 44 ++++ include/linux/magic.h | 3 + include/linux/syscalls.h | 4 - kernel/checkpoint/Makefile | 6 +- kernel/checkpoint/checkpoint.c | 213 ++++++++++++++++++ kernel/checkpoint/process.c | 101 +++++++++ kernel/checkpoint/restart.c | 460 +++++++++++++++++++++++++++++++++++++ kernel/checkpoint/sys.c | 461 +++++++++++++++++++++++++++++++++++++- lib/Kconfig.debug | 13 + 12 files changed, 1632 insertions(+), 13 deletions(-) create mode 100644 include/linux/checkpoint.h create mode 100644 include/linux/checkpoint_hdr.h create mode 100644 include/linux/checkpoint_types.h create mode 100644 kernel/checkpoint/checkpoint.c create mode 100644 kernel/checkpoint/process.c create mode 100644 kernel/checkpoint/restart.c
include/linux/Kbuild +3 -0
@@ -81,6 +81,9 @@ header-y += cciss_ioctl.h header-y += cdk.h header-y += cdrom.h header-y += cgroupstats.h +header-y += checkpoint.h +header-y += checkpoint_hdr.h +header-y += checkpoint_types.h header-y += chio.h header-y += cm4000_cs.h header-y += cn_proc.h
include/linux/checkpoint.h new file +202 -0
202 lines not on this page · raw message
include/linux/checkpoint_hdr.h new file +135 -0
135 lines not on this page · raw message
include/linux/checkpoint_types.h new file +44 -0
44 lines not on this page · raw message
include/linux/magic.h +3 -0
@@ -59,4 +59,7 @@#define SOCKFS_MAGIC 0x534F434B#define V9FS_MAGIC 0x01021997 +#define CHECKPOINT_MAGIC_HEAD 0x00feed0cc0a2d200LL +#define CHECKPOINT_MAGIC_TAIL 0x002d2a0cc0deef00LL +#endif /* __LINUX_MAGIC_H__ */
include/linux/syscalls.h +0 -4
@@ -820,10 +820,6 @@ asmlinkage long sys_fanotify_init(unsigned int flags, unsigned int event_f_flagsasmlinkage long sys_fanotify_mark (int fanotify_fd,unsigned int flags,u64 mask,int fd,const char __user *pathname); -asmlinkage long sys_checkpoint (pid_t pid,int fd,unsigned long flags, -int logfd); -asmlinkage long sys_restart (pid_t pid,int fd,unsigned long flags, -int logfd);int kernel_execve (const char *filename,const char *const argv[],const char *const envp[]);
kernel/checkpoint/Makefile +5 -1
@@ -2,4 +2,8 @@ # Makefile for linux checkpoint/restart. # -obj-$(CONFIG_CHECKPOINT) += sys.o +obj-$(CONFIG_CHECKPOINT) += \ + sys.o \ + checkpoint.o \ + restart.o \ + process.o
kernel/checkpoint/checkpoint.c new file +213 -0
213 lines not on this page · raw message
kernel/checkpoint/process.c new file +101 -0
101 lines not on this page · raw message
kernel/checkpoint/restart.c new file +460 -0
460 lines not on this page · raw message
kernel/checkpoint/sys.c +453 -8
487 lines not on this page · raw message
lib/Kconfig.debug +13 -0
@@ -1230,6 +1230,19 @@ config ASYNC_RAID6_TEST If unsure, say N. +config CHECKPOINT_DEBUG + bool "Checkpoint/restart debugging (EXPERIMENTAL)" + depends on CHECKPOINT + default y + help + This options turns on the debugging output of checkpoint/restart. + The level of verbosity is controlled by 'ckpt_debug_level' and can + be set at boot time with "ckpt_debug=" option. + + Turning this option off will reduce the size of the c/r code. If + turned on, it is unlikely to incur visible overhead if the debug + level is set to zero. + source "samples/Kconfig" source "lib/Kconfig.kgdb"
Signature · 8 lines
1.7.2.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Fight unfair telecom policy in Canada: sign http://dissolvethecrtc.ca/ Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 12/19 c/r: introduce vfs_fcntl()
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
This patch introduces vfs_fcntl() so that it can be called from restart (see patch adding restart of files).
--- fs/fcntl.c | 21 +++++++++++++-------- include/linux/fs.h | 2 ++ 2 files changed, 15 insertions(+), 8 deletions(-)
fs/fcntl.c +13 -8
@@ -426,6 +426,18 @@ static long do_fcntl(int fd, unsigned int cmd, unsigned long arg,return err; } +int vfs_fcntl (int fd,unsigned int cmd,unsigned long arg,struct file *filp) +{ +int err; + + err =security_file_fcntl (filp, cmd, arg); +if (err) + goto out; + err =do_fcntl (fd, cmd, arg, filp); + out: +return err; +} + SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg) {struct file *filp;
@@ -435,14 +447,7 @@ SYSCALL_DEFINE3(fcntl, unsigned int, fd, unsigned int, cmd, unsigned long, arg)if (!filp) goto out; - err =security_file_fcntl (filp, cmd, arg); -if (err) { -fput (filp); -return err; - } - - err =do_fcntl (fd, cmd, arg, filp); - + err =vfs_fcntl (fd, cmd, arg, filp);fput (filp); out:return err;
include/linux/fs.h +2 -0
@@ -1111,6 +1111,8 @@ struct file_lock {#include <linux/fcntl.h> +extern int vfs_fcntl (int fd,unsigned cmd,unsigned long arg,struct file *fp); +extern void send_sigio (struct fown_struct *fown,int fd,int band);#ifdef CONFIG_FILE_LOCKING
Signature · 1 line
1.7.2.2
PATCH 13/19 c/r: introduce new 'file_operations': ->checkpoint, ->collect()
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
While we assume all normal files and directories can be checkpointed, there are, as usual in the VFS, specialized places that will always need an ability to override these defaults. Although we could do this completely in the checkpoint code, that would bitrot quickly.
This adds a new 'file_operations' function for checkpointing a file. It is assumed that there should be a dirt-simple way to make something (un)checkpointable that fits in with current code.
As you can see in the ext[234] patches down the road, all that we have to do to make something simple be supported is add a single "generic" f_op entry.
Also adds a new 'file_operations' function for 'collecting' a file for leak-detection during full-container checkpoint. This is useful for those files that hold references to other "collectable" objects. Two examples are pty files that point to corresponding tty objects, and eventpoll files that refer to the files they are monitoring.
Finally, this patch introduces vfs_fcntl() so that it can be called from restart (see patch adding restart of files).
Changelog[v21]
- Update Documentation/filesystem/vfs.txt
- Put file_ops->checkpoint under CONFIG_CHECKPOINT
Changelog[v17]
- Introduce 'collect' method
Changelog[v17]
- Forward-declare 'ckpt_ctx' et-al, don't use checkpoint_types.h
--- Documentation/filesystems/vfs.txt | 13 ++++++++++++- include/linux/fs.h | 5 +++++ 2 files changed, 17 insertions(+), 1 deletions(-)
Documentation/filesystems/vfs.txt +12 -1
@@ -716,7 +716,7 @@ struct file_operations ---------------------- This describes how the VFS can manipulate an open file. As of kernel -2.6.22, the following members are defined: +2.6.34, the following members are defined: struct file_operations { struct module *owner;
@@ -746,6 +746,10 @@ struct file_operations { int (*flock) (struct file *, int, struct file_lock *); ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, size_t, unsigned int); ssize_t (*splice_read)(struct file *, struct pipe_inode_info *, size_t, unsigned int); +#ifdef CONFIG_CHECKPOINT + int (*checkpoint)(struct ckpt_ctx *, struct file *); + int (*collect)(struct ckpt_ctx *, struct file *); +#endif }; Again, all methods are called without any locks being held, unless
@@ -814,6 +818,13 @@ otherwise noted. splice_read: called by the VFS to splice data from file to a pipe. This method is used by the splice(2) system call + checkpoint: called by checkpoint(2) system call to checkpoint the + state of a file descriptor. + + collect: called by the checkpoint(2) system call to track references to + file descriptors, to detect leaks in full-container checkpoint + (see Documentation/checkpoint/readme.txt). + Note that the file operations are implemented by the specific filesystem in which the inode resides. When opening a device node (character or block special) most filesystems will call special
include/linux/fs.h +5 -0
@@ -407,6 +407,7 @@ struct kstatfs;struct vm_area_struct ;struct vfsmount ;struct cred ; +struct ckpt_ctx ;extern void __init inode_init (void );extern void __init inode_init_early (void );
@@ -1544,6 +1545,10 @@ struct file_operations {ssize_t (*splice_write)(struct pipe_inode_info *,struct file *,loff_t *,size_t ,unsigned int );ssize_t (*splice_read)(struct file *,loff_t *,struct pipe_inode_info *,size_t ,unsigned int );int (*setlease)(struct file *,long ,struct file_lock **); +#ifdef CONFIG_CHECKPOINT +int (*checkpoint)(struct ckpt_ctx *,struct file *); +int (*collect)(struct ckpt_ctx *,struct file *); +#endif };struct inode_operations {
Signature · 1 line
1.7.2.2
PATCH 14/19 c/r: checkpoint and restart open file descriptors
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
Checkpoint: dump the file table with 'struct ckpt_hdr_file_table, followed by all open file descriptors. Because the 'struct file' corresponding to an fd can be shared, they are assigned an objref and registered in the object hash. A reference to the 'file *' is kept for as long as it lives in the hash (the hash is only cleaned up at the end of the checkpoint).
Also provide generic_checkpoint_file() and generic_restore_file() which is good for normal files and directories. It does not support yet unlinked files or directories.
Restart: for each fd read 'struct ckpt_hdr_file_desc' and lookup objref in the hash table; If not found in the hash table, (first occurence), read in 'struct ckpt_hdr_file', create a new file and register in the hash. Otherwise attach the file pointer from the hash as an FD.
Changelog[37rc2]:
- [Dan Smith] Remove collect-related bits
- [Dan Smith] Remove lock around __d_path because of new behavior
- [Dan Smith] Remove BUG() on refcount since I left out the multi-process stuff and it doesn't get updated properly
Changelog[v21]:
- Do not include checkpoint_hdr.h explicitly
- Replace __initcall() with late_initcall()
- [Serge] Print out full path of file which crossed mnt_ns
- Reorganize code into fs/*
- Merge files dump/restore into a single patch
- Put file_ops->checkpoint under CONFIG_CHECKPOINT
Changelog[v19]:
- Fix false negative of test for unlinked files at checkpoint
Changelog[v19-rc3]:
- [Serge Hallyn] Rename fs_mnt to root_fs_path
- [Dave Hansen] Error out on file locks and leases
- [Serge Hallyn] Refuse checkpoint of file with f_owner
Changelog[v19-rc1]:
- Fix lockdep complaint in restore_obj_files()
- [Matt Helsley] Add cpp definitions for enums
- Restore thread/cpu state early
- Ensure null-termination of file names read from image
- Fix compile warning in restore_open_fname()
Changelog[v18]:
- Add a few more ckpt_write_err()s
- [Dan Smith] Export fill_fname() as ckpt_fill_fname()
- Introduce ckpt_collect_file() that also uses file->collect method
- In collect_file_stabl() use retval from ckpt_obj_collect() to test for first-time-object
- Invoke set_close_on_exec() unconditionally on restart
Changelog[v17]:
- Validate f_mode after restore against saved f_mode
- Fail if f_flags have O_CREAT|O_EXCL|O_NOCTTY|O_TRUNC
- Reorder patch (move earlier in series)
- Handle shared files_struct objects
- Only collect sub-objects of files_struct once
- Better file error debugging
- Use (new) d_unlinked()
Changelog[v16]:
- Fix compile warning in checkpoint_bad()
Changelog[v16]:
- Reorder patch (move earlier in series)
- Handle shared files_struct objects
Changelog[v14]:
- File objects are dumped/restored prior to the first reference
- Introduce a per file-type restore() callback
- Use struct file_operations->checkpoint()
- Put code for generic file descriptors in a separate function
- Use one CKPT_FILE_GENERIC for both regular files and dirs
- Revert change to pr_debug(), back to ckpt_debug()
- Use only unsigned fields in checkpoint headers
- Rename: ckpt_write_files() => checkpoint_fd_table() - Rename: ckpt_write_fd_data() => checkpoint_file() - Rename: ckpt_read_fd_data() => restore_file() - Rename: restore_files() => restore_fd_table()
- Check whether calls to ckpt_hbuf_get() fail
- Discard field 'h->parent'
Changelog[v12]:
- Replace obsolete ckpt_debug() with pr_debug()
Changelog[v11]:
- Discard handling of opened symlinks (there is no such thing)
- ckpt_scan_fds() retries from scratch if hits size limits
Changelog[v9]:
- Fix a couple of leaks in ckpt_write_files()
- Drop useless kfree from ckpt_scan_fds()
Changelog[v8]:
- initialize 'coe' to workaround gcc false warning
Changelog[v6]:
- Balance all calls to ckpt_hbuf_get() with matching ckpt_hbuf_put() (even though it's not really needed)
--- fs/Makefile | 6 + fs/checkpoint.c | 721 ++++++++++++++++++++++++++++++++++++++ fs/locks.c | 35 ++ include/linux/checkpoint.h | 26 ++ include/linux/checkpoint_hdr.h | 93 +++++ include/linux/checkpoint_types.h | 5 + include/linux/fs.h | 10 + kernel/checkpoint/checkpoint.c | 11 + kernel/checkpoint/process.c | 52 +++- kernel/checkpoint/sys.c | 9 + 10 files changed, 966 insertions(+), 2 deletions(-) create mode 100644 fs/checkpoint.c
fs/Makefile +6 -0
@@ -30,6 +30,12 @@ obj-$(CONFIG_AIO) += aio.o obj-$(CONFIG_FILE_LOCKING) += locks.o obj-$(CONFIG_COMPAT) += compat.o compat_ioctl.o obj-$(CONFIG_NFSD_DEPRECATED) += nfsctl.o + +nfsd-$(CONFIG_NFSD) := nfsctl.o +obj-y += $(nfsd-y) $(nfsd-m) + +obj-$(CONFIG_CHECKPOINT) += checkpoint.o + obj-$(CONFIG_BINFMT_AOUT) += binfmt_aout.o obj-$(CONFIG_BINFMT_EM86) += binfmt_em86.o obj-$(CONFIG_BINFMT_MISC) += binfmt_misc.o
fs/checkpoint.c new file +721 -0
721 lines not on this page · raw message
fs/locks.c +35 -0
@@ -2038,6 +2038,41 @@ void locks_remove_posix(struct file *filp, fl_owner_t owner)EXPORT_SYMBOL (locks_remove_posix); +int find_locks_with_owner (struct file *filp,fl_owner_t owner) +{ +struct inode *inode = filp->f_path.dentry->d_inode; +struct file_lock **inode_fl; +int ret = -EEXIST ; + +lock_kernel (); +for_each_lock (inode, inode_fl) { +struct file_lock *fl = *inode_fl; +/* +* We could use posix_same_owner() along with a 'fake' +* file_lock. But, the fake file will never have the +* same fl_lmops as the fl that we are looking for and +* posix_same_owner() would just fall back to this +* check anyway. +*/ +if (IS_POSIX (fl)) { +if (fl->fl_owner == owner) { + ret =0 ; +break ; + } + }else if (IS_FLOCK (fl) ||IS_LEASE (fl)) { +if (fl->fl_file == filp) { + ret =0 ; +break ; + } + }else { +WARN (1 ,"unknown file lock type, fl_flags: %x" , + fl->fl_flags); + } + } +unlock_kernel (); +return ret; +} +/* * This function is called on the last close of an open file. */
include/linux/checkpoint.h +26 -0
@@ -63,6 +63,9 @@ extern int ckpt_read_payload(struct ckpt_ctx *ctx,extern char *ckpt_read_string (struct ckpt_ctx *ctx,int max);extern int ckpt_read_consume (struct ckpt_ctx *ctx,int len,int type); +extern char *ckpt_fill_fname (struct path *path,struct path *root, +char *buf,int *len); +/* ckpt kflags */ #define ckpt_set_ctx_kflag (__ctx, __kflag) \ set_bit(__kflag##_BIT, &(__ctx)->kflags)
@@ -124,6 +127,28 @@ extern int restore_read_header_arch(struct ckpt_ctx *ctx);extern int restore_thread (struct ckpt_ctx *ctx);extern int restore_cpu (struct ckpt_ctx *ctx); +extern int checkpoint_restart_block (struct ckpt_ctx *ctx, +struct task_struct *t); +extern int restore_restart_block (struct ckpt_ctx *ctx); + +/* file table */ +extern int ckpt_collect_file_table (struct ckpt_ctx *ctx,struct task_struct *t); +extern int checkpoint_obj_file_table (struct ckpt_ctx *ctx, +struct task_struct *t); +extern int restore_obj_file_table (struct ckpt_ctx *ctx,int files_objref); + +/* files */ +extern int checkpoint_fname (struct ckpt_ctx *ctx, +struct path *path,struct path *root); +extern struct file *restore_open_fname (struct ckpt_ctx *ctx,int flags); + +extern int ckpt_collect_file (struct ckpt_ctx *ctx,struct file *file); + +extern int checkpoint_file_common (struct ckpt_ctx *ctx,struct file *file, +struct ckpt_hdr_file *h); +extern int restore_file_common (struct ckpt_ctx *ctx,struct file *file, +struct ckpt_hdr_file *h); +static inline int ckpt_validate_errno (int errno) {return (errno >=0 ) && (errno <MAX_ERRNO );
@@ -134,6 +159,7 @@ static inline int ckpt_validate_errno(int errno)#define CKPT_DSYS 0x2/* generic (system) */ #define CKPT_DRW 0x4/* image read/write */ #define CKPT_DOBJ 0x8/* shared objects */ +#define CKPT_DFILE 0x10/* files and filesystem */ #define CKPT_DDEFAULT 0xffff/* default debug level */
include/linux/checkpoint_hdr.h +93 -0
115 lines not on this page · raw message
include/linux/checkpoint_types.h +5 -0
@@ -14,6 +14,8 @@#include <linux/sched.h> #include <linux/nsproxy.h> +#include <linux/list.h> +#include <linux/path.h> #include <linux/fs.h> struct ckpt_ctx {
@@ -35,6 +37,9 @@ struct ckpt_ctx {atomic_t refcount;struct ckpt_obj_hash *obj_hash;/* repository for shared objects */ +struct deferqueue_head *files_deferq;/* deferred file-table work */ + +struct path root_fs_path;/* container root (FIXME) */ struct task_struct *tsk;/* checkpoint: current target task */ char err_string[256 ];/* checkpoint: error string */
include/linux/fs.h +10 -0
@@ -1140,6 +1140,7 @@ extern void locks_remove_posix(struct file *, fl_owner_t);extern void locks_remove_flock (struct file *);extern void locks_release_private (struct file_lock *);extern void posix_test_lock (struct file *,struct file_lock *); +extern int find_locks_with_owner (struct file *filp,fl_owner_t owner);extern int posix_lock_file (struct file *,struct file_lock *,struct file_lock *);extern int posix_lock_file_wait (struct file *,struct file_lock *);extern int posix_unblock_lock (struct file *,struct file_lock *);
@@ -1210,6 +1211,11 @@ static inline void locks_remove_posix(struct file *filp, fl_owner_t owner)return ; } +static inline int find_locks_with_owner (struct file *filp,fl_owner_t owner) +{ +return -ENOENT ; +} +static inline void locks_remove_flock (struct file *filp) {return ;
@@ -2377,6 +2383,10 @@ void inode_sub_bytes(struct inode *inode, loff_t bytes);loff_t inode_get_bytes (struct inode *inode);void inode_set_bytes (struct inode *inode,loff_t bytes); +#ifdef CONFIG_CHECKPOINT +extern int generic_file_checkpoint (struct ckpt_ctx *ctx,struct file *file); +#endif +extern int vfs_readdir (struct file *,filldir_t ,void *);extern int vfs_stat (const char __user *,struct kstat *);
kernel/checkpoint/checkpoint.c +11 -0
@@ -19,6 +19,7 @@#include <linux/time.h> #include <linux/fs.h> #include <linux/file.h> +#include <linux/fs_struct.h> #include <linux/dcache.h> #include <linux/mount.h> #include <linux/utsname.h>
@@ -229,6 +230,7 @@ static int init_checkpoint_ctx(struct ckpt_ctx *ctx, pid_t pid)struct task_struct *task;struct nsproxy *nsproxy;int ret; +struct fs_struct *fs;/* * No need for explicit cleanup here, because if an error
@@ -274,6 +276,15 @@ static int init_checkpoint_ctx(struct ckpt_ctx *ctx, pid_t pid)return ret; } +/* root vfs (FIX: WILL CHANGE with mnt-ns etc */ +task_lock (ctx->root_task); + fs = ctx->root_task->fs; +spin_lock (&fs->lock); + ctx->root_fs_path = fs->root; +path_get (&ctx->root_fs_path); +spin_unlock (&fs->lock); +task_unlock (ctx->root_task); +return 0 ; }
kernel/checkpoint/process.c +50 -2
81 lines not on this page · raw message
kernel/checkpoint/sys.c +9 -0
@@ -22,6 +22,7 @@#include <linux/file.h> #include <linux/uaccess.h> #include <linux/capability.h> +#include <linux/deferqueue.h> #include <linux/checkpoint.h> /*
@@ -161,12 +162,16 @@ EXPORT_SYMBOL(ckpt_hdr_get_type);static void ckpt_ctx_free (struct ckpt_ctx *ctx) { +if (ctx->files_deferq) +deferqueue_destroy (ctx->files_deferq); +if (ctx->file)fput (ctx->file);if (ctx->logfile)fput (ctx->logfile);ckpt_obj_hash_free (ctx); +path_put (&ctx->root_fs_path);if (ctx->root_nsproxy)put_nsproxy (ctx->root_nsproxy);
@@ -208,6 +213,10 @@ static struct ckpt_ctx *ckpt_ctx_alloc(int fd, unsigned long uflags,if (ckpt_obj_hash_alloc (ctx) <0 ) goto err; + ctx->files_deferq =deferqueue_create (); +if (!ctx->files_deferq) + goto err; +atomic_inc (&ctx->refcount);return ctx; err:
Signature · 1 line
1.7.2.2
DS> Cc: [email protected]
DS> Cc: [email protected]
DS> Cc: [email protected]
DS> Signed-off-by: Alexey Dobriyan <[email protected]> DS> Signed-off-by: Oren Laadan <[email protected]>
My apologies to the above mentioned recipients. I did not mean to send this out. Please ignore.
Signature · 3 lines
Dan Smith IBM Linux Technology Center email: [email protected]
PATCH 15/19 c/r: introduce method '->checkpoint()' in struct vm_operations_struct
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
Changelog[v17]
- Forward-declare 'ckpt_ctx et-al, don't use checkpoint_types.h
--- include/linux/mm.h | 5 +++++ 1 files changed, 5 insertions(+), 0 deletions(-)
include/linux/mm.h +5 -0
@@ -20,6 +20,8 @@ struct anon_vma;struct file_ra_state ;struct user_struct ;struct writeback_control ; +struct rlimit ; +struct ckpt_ctx ;#ifndef CONFIG_DISCONTIGMEM /* Don't use mapnrs, do it properly */ extern unsigned long max_mapnr;
@@ -229,6 +231,9 @@ struct vm_operations_struct {int (*migrate)(struct vm_area_struct *vma,const nodemask_t *from,const nodemask_t *to,unsigned long flags);#endif +#ifdef CONFIG_CHECKPOINT +int (*checkpoint)(struct ckpt_ctx *ctx,struct vm_area_struct *vma); +#endif };struct mmu_gather ;
Signature · 8 lines
1.7.2.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Fight unfair telecom policy in Canada: sign http://dissolvethecrtc.ca/ Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 16/19 Introduce FOLL_DIRTY to follow_page() for "dirty" pages
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
This is a preparatory patch necessary for checkpoint/restart (next two patches) of memory to work correctly.
The patch introduces a new FOLL_DIRTY flag which tells follow_page() to return -EFAULT also for not-present file-backed pages.
In 2.6.32 follow_page() changes its behavior due to this commit:
mm: FOLL_DUMP replace FOLL_ANON 8e4b9a60718970bbc02dfd3abd0b956ab65af231
Also introduce __get_dirty_page() that returns a page only if it's "dirty", that is that has been modified before, and otherwise returns NULL. It uses FOLL_DUMP | FOLL_DIRTY and converts the error value EFAULT to NULL - telling the caller that the page in question is clean.
(This also optimizes for checkpoint in the next patch: before, if a file-backed page was not-present we would first fault it in (read from disk) and then detect that it was virgin. Instead, now we detect that the page is clean earlier without needing to fault it in).
To see why it's needed, consider these scenarios:
1. Task maps a file beyond it's limit, never touches those extra page (if it did, it would get EFAULT/Bus error)
2. Task maps a file and writes the last page, then the file gets truncated (by at least a page). A subsequent access to the page will cause bus error (VM_FAULT_SIGBUS).
3. If the file size is extended back (using truncate) and the task accesses that page, then the task will get a fresh page (losing data it had written to that address before).
[Before kernel 2.6.32, that page would become anonymous once it was dirtied, such that accesses in case #2 are valid, and in case #3 the task would see the old page regardless of the file contents.]
--CHECKPOINT: before we used FOLL_ANON flags to tell follow_page() to return the zero-page for case#1. For case#2, the actual page was returned. Without this patch, In kernel 2.3.32, FOLL_DUMP would make follow_page() return NULL and then fault handler would have returned VM_FAULT_SIGBUS in case#1 (and depending on arch, case#2 too), and checkpoint would fails.
--RESTART: case #1 works, because mmap() works as before, and those pages that were never touched will not be restored either, they will remain untouched. The same holds for case#2 (as of kernel 2.6.32), because at checkpoint it would decide that the page is clean and not save the contents, and therefore it will not try to restore the contents at restart. This is consistent with the expected behavior after restart: if the file remains as is, subsequent accesses will trigger a bus error, and if the file is extended, then the user will observe a fresh page.
--- include/linux/mm.h | 2 + mm/memory.c | 95 +++++++++++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 96 insertions(+), 1 deletions(-)
include/linux/mm.h +2 -0
@@ -866,6 +866,7 @@ int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,int get_user_pages_fast (unsigned long start,int nr_pages,int write,struct page **pages);struct page *get_dump_page (unsigned long addr); +struct page *__get_dirty_page (struct vm_area_struct *vma,unsigned long addr);extern int try_to_release_page (struct page * page,gfp_t gfp_mask);extern void do_invalidatepage (struct page *page,unsigned long offset);
@@ -1420,6 +1421,7 @@ struct page *follow_page(struct vm_area_struct *, unsigned long address,#define FOLL_GET 0x04/* do get_page on page */ #define FOLL_DUMP 0x08/* give error on hole if it would be zero */ #define FOLL_FORCE 0x10/* get_user_pages read/write w/o permission */ +#define FOLL_DIRTY 0x20/* give error on non-present file mapped */ typedef int (*pte_fn_t )(pte_t *pte,pgtable_t token,unsigned long addr,void *data);
mm/memory.c +94 -1
114 lines not on this page · raw message
Signature · 8 lines
1.7.2.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Fight unfair telecom policy in Canada: sign http://dissolvethecrtc.ca/ Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 17/19 c/r: dump memory address space (private memory)
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
For each vma, there is a 'struct ckpt_vma'; Then comes the actual contents, in one or more chunk: each chunk begins with a header that specifies how many pages it holds, then the virtual addresses of all the dumped pages in that chunk, followed by the actual contents of all dumped pages. A header with zero number of pages marks the end of the contents. Then comes the next vma and so on.
To checkpoint a vma, call the ops->checkpoint() method of that vma. Normally the per-vma function will invoke generic_vma_checkpoint() which first writes the vma description, followed by the specific logic to dump the contents of the pages.
Currently for private mapped memory we save the pathname of the file that is mapped (restart will use it to re-open it and then map it). Later we change that to reference a file object.
Restoring the memory address space begins with nuking the existing one of the current process, and then reading the vma state and contents. Call do_mmap_pgoffset() for each vma and then read in the data.
Changelog[37rc2]:
- [Dan Smith] Stripped out collect bits
Changelog[v21]:
- Do not include checkpoint_hdr.h explicitly
- Replace __initcall() with late_initcall()
- Merge mm dump/restore into a single patch
- Put file_ops->checkpoint under CONFIG_CHECKPOINT
Changelog[v20]:
- Only use arch_setup_additional_pages() if supported by arch
Changelog[v19]:
- [Serge Hallyn] Checkpoint saved_auxv as u64s
- [Serge Hallyn] do_munmap(): remove unused local vars
Changelog[v19-rc3]:
- Separate __get_dirty_page() into its own patch
- Export filemap_checkpoint()
- [Serge Hallyn] Disallow checkpoint of tasks with aio requests
- Fix compilation failure when !CONFIG_CHEKCPOINT (regression)
- [Serge Hallyn] move destroy_mm into mmap.c and remove size check
- [Serge Hallyn] fill vdso (syscall32_setup_pages) for TIF_IA32/x86_64
- Do not hold mmap_sem when reading memory pages on restart
Changelog[v19-rc2]:
- Expose page write functions
- Take mmap_sem() around vma_fill_pgarr() (fix regression)
- Move consider_private_page() to mm/memory.c:__get_dirty_page()
- Expose page write functions
- [Serge Hallyn] Fix return value of read_pages_contents()
Changelog[v19-rc1]:
- [Matt Helsley] Add cpp definitions for enums
- Do not hold mmap_sem while checkpointing vma's
Changelog[v18]:
- Tighten checks on supported vma to checkpoint or restart
- Add a few more ckpt_write_err()s
- [Serge Hallyn] Export filemap_checkpoint() (used later for ext4)
- Use ckpt_collect_file() instead of ckpt_obj_collect() for files
- In collect_mm() use retval from ckpt_obj_collect() to test for first-time-object
- Tighten checks on supported vma to checkpoint or restart
Changelog[v17]:
- Only collect sub-objects of mm_struct once
- Save mm->{flags,def_flags,saved_auxv}
- Restore mm->{flags,def_flags,saved_auxv}
- Fix bogus warning in do_restore_mm()
Changelog[v16]:
- Precede vaddrs/pages with a buffer header
- Checkpoint mm->exe_file
- Handle shared task->mm
- Restore mm->exe_file
Changelog[v14]:
- Modify the ops->checkpoint method to be much more powerful
- Improve support for VDSO (with special_mapping checkpoint callback)
- Save new field 'vdso' in mm_context
- Revert change to pr_debug(), back to ckpt_debug()
- Check whether calls to ckpt_hbuf_get() fail
- Discard field 'h->parent'
- Introduce per vma-type restore() function
- Merge restart code into same file as checkpoint (memory.c)
- Compare saved 'vdso' field of mm_context with current value
Changelog[v13]:
- pgprot_t is an abstract type; use the proper accessor (fix for 64-bit powerpc (Nathan Lynch <[email protected]>)
- Avoid access to hh->vma_type after the header is freed (restart)
- Test for no vma's in exit_mmap() before calling unmap_vma() (or it may crash if restart fails after having removed all vma's)
Changelog[v12]:
- Hide pgarr management inside ckpt_private_vma_fill_pgarr()
- Fix management of pgarr chain reset and alloc/expand: keep empty pgarr in a pool chain
- Replace obsolete ckpt_debug() with pr_debug()
Changelog[v11]:
- Copy contents of 'init->fs->root' instead of pointing to them.
- Add missing test for VM_MAYSHARE when dumping memory
Changelog[v10]:
- Acquire dcache_lock around call to __d_path() in ckpt_fill_name()
Changelog[v9]:
- Introduce ckpt_ctx_checkpoint() for checkpoint-specific ctx setup
- Test if __d_path() changes mnt/dentry (when crossing filesystem namespace boundary). for now ckpt_fill_fname() fails the checkpoint.
Changelog[v7]:
- Fix argument given to kunmap_atomic() in memory dump/restore
Changelog[v6]:
- Balance all calls to ckpt_hbuf_get() with matching ckpt_hbuf_put() (even though it's not really needed)
Changelog[v5]:
- Improve memory dump code (following Dave Hansen's comments)
- Change dump format (and code) to allow chunks of <vaddrs, pages> instead of one long list of each
- Fix use of follow_page() to avoid faulting in non-present pages
- Memory restore now maps user pages explicitly to copy data into them, instead of reading directly to user space; got rid of mprotect_fixup()
Changelog[v4]:
- Use standard list_... for ckpt_pgarr
--- arch/x86/include/asm/checkpoint_hdr.h | 9 + arch/x86/include/asm/ldt.h | 7 + arch/x86/kernel/checkpoint.c | 95 +++ fs/aio.c | 17 + fs/exec.c | 2 +- include/linux/aio.h | 2 + include/linux/checkpoint.h | 34 + include/linux/checkpoint_hdr.h | 62 ++ include/linux/checkpoint_types.h | 21 + include/linux/mm.h | 19 + kernel/checkpoint/checkpoint.c | 2 + kernel/checkpoint/process.c | 12 + kernel/checkpoint/restart.c | 3 + kernel/checkpoint/sys.c | 17 + mm/Makefile | 6 + mm/checkpoint.c | 1159 +++++++++++++++++++++++++++++++++ mm/filemap.c | 45 ++ mm/mmap.c | 101 +++- 18 files changed, 1607 insertions(+), 6 deletions(-) create mode 100644 mm/checkpoint.c
arch/x86/include/asm/checkpoint_hdr.h +9 -0
@@ -44,6 +44,8 @@enum {CKPT_HDR_CPU_FPU =201 ,#define CKPT_HDR_CPU_FPU CKPT_HDR_CPU_FPU + CKPT_HDR_MM_CONTEXT_LDT, +#define CKPT_HDR_MM_CONTEXT_LDT CKPT_HDR_MM_CONTEXT_LDT };struct ckpt_hdr_header_arch {
@@ -109,4 +111,11 @@ struct ckpt_hdr_cpu {#define CKPT_X86_SEG_TLS 0x4000/* 0100 0000 0000 00xx */ #define CKPT_X86_SEG_LDT 0x8000/* 100x xxxx xxxx xxxx */ +struct ckpt_hdr_mm_context { +struct ckpt_hdr h; +__u64 vdso; +__u32 ldt_entry_size; +__u32 nldt; +} __attribute__((aligned (8 ))); +#endif /* __ASM_X86_CKPT_HDR__H */
arch/x86/include/asm/ldt.h +7 -0
@@ -37,4 +37,11 @@ struct user_desc {#define MODIFY_LDT_CONTENTS_CODE 2#endif /* !__ASSEMBLY__ */ + +#ifdef __KERNEL__ +#include <linux/linkage.h> +asmlinkage int sys_modify_ldt(int func, void __user *ptr, +unsigned long bytecount); +#endif +#endif /* _ASM_X86_LDT_H */
arch/x86/kernel/checkpoint.c +95 -0
110 lines not on this page · raw message
fs/aio.c +17 -0
@@ -1847,3 +1847,20 @@ SYSCALL_DEFINE5(io_getevents, aio_context_t, ctx_id,asmlinkage_protect (5 , ret, ctx_id, min_nr, nr, events, timeout);return ret; } + +int check_for_outstanding_aio (struct mm_struct *mm) +{ +struct kioctx *ctx; +struct hlist_node *n; +int ret =0 ; + +rcu_read_lock (); +hlist_for_each_entry_rcu (ctx, n, &mm->ioctx_list, list) { +if (!ctx->dead) { + ret = -EBUSY ; +break ; + } + } +rcu_read_unlock (); +return ret; +}
fs/exec.c +1 -1
@@ -796,7 +796,7 @@ ssize_t kernel_write(struct file *file, loff_t offset,EXPORT_SYMBOL (kernel_write); -static int exec_mmap (struct mm_struct *mm) +int exec_mmap (struct mm_struct *mm) {struct task_struct *tsk;struct mm_struct * old_mm, *active_mm;
include/linux/aio.h +2 -0
@@ -214,6 +214,7 @@ struct mm_struct;extern void exit_aio (struct mm_struct *mm);extern long do_io_submit (aio_context_t ctx_id,long nr,struct iocb __user *__user *iocbpp,bool compat); +extern int check_for_outstanding_aio (struct mm_struct *mm);#else static inline ssize_t wait_on_sync_kiocb (struct kiocb *iocb) {return 0 ; }static inline int aio_put_req (struct kiocb *iocb) {return 0 ; }
@@ -224,6 +225,7 @@ static inline void exit_aio(struct mm_struct *mm) { }static inline long do_io_submit (aio_context_t ctx_id,long nr,struct iocb __user *__user *iocbpp,bool compat) {return 0 ; } +static inline int check_for_outstanding_aio (struct mm_struct *mm) {return 0 ; }#endif /* CONFIG_AIO */ static inline struct kiocb *list_kiocb (struct list_head *h)
include/linux/checkpoint.h +34 -0
@@ -66,6 +66,9 @@ extern int ckpt_read_consume(struct ckpt_ctx *ctx, int len, int type);extern char *ckpt_fill_fname (struct path *path,struct path *root,char *buf,int *len); +extern int checkpoint_dump_page (struct ckpt_ctx *ctx,struct page *page); +extern int restore_read_page (struct ckpt_ctx *ctx,struct page *page); +/* ckpt kflags */ #define ckpt_set_ctx_kflag (__ctx, __kflag) \ set_bit(__kflag##_BIT, &(__ctx)->kflags)
@@ -122,10 +125,12 @@ extern int restore_task(struct ckpt_ctx *ctx);extern int checkpoint_write_header_arch (struct ckpt_ctx *ctx);extern int checkpoint_thread (struct ckpt_ctx *ctx,struct task_struct *t);extern int checkpoint_cpu (struct ckpt_ctx *ctx,struct task_struct *t); +extern int checkpoint_mm_context (struct ckpt_ctx *ctx,struct mm_struct *mm);extern int restore_read_header_arch (struct ckpt_ctx *ctx);extern int restore_thread (struct ckpt_ctx *ctx);extern int restore_cpu (struct ckpt_ctx *ctx); +extern int restore_mm_context (struct ckpt_ctx *ctx,struct mm_struct *mm);extern int checkpoint_restart_block (struct ckpt_ctx *ctx,struct task_struct *t);
@@ -149,6 +154,33 @@ extern int checkpoint_file_common(struct ckpt_ctx *ctx, struct file *file,extern int restore_file_common (struct ckpt_ctx *ctx,struct file *file,struct ckpt_hdr_file *h); +/* memory */ +extern void ckpt_pgarr_free (struct ckpt_ctx *ctx); + +extern int generic_vma_checkpoint (struct ckpt_ctx *ctx, +struct vm_area_struct *vma, +enum vma_type type, +int vma_objref); +extern int private_vma_checkpoint (struct ckpt_ctx *ctx, +struct vm_area_struct *vma, +enum vma_type type, +int vma_objref); + +extern int checkpoint_obj_mm (struct ckpt_ctx *ctx,struct task_struct *t); +extern int restore_obj_mm (struct ckpt_ctx *ctx,int mm_objref); + +extern int ckpt_collect_mm (struct ckpt_ctx *ctx,struct task_struct *t); + +extern int private_vma_restore (struct ckpt_ctx *ctx,struct mm_struct *mm, +struct file *file,struct ckpt_hdr_vma *h); + + +#define CKPT_VMA_NOT_SUPPORTED \ + (VM_SHARED | VM_MAYSHARE | VM_IO | VM_HUGETLB | \ + VM_NONLINEAR | VM_PFNMAP | VM_RESERVED | VM_NORESERVE \ + | VM_HUGETLB | VM_NONLINEAR | VM_MAPPED_COPY | \ + VM_INSERTPAGE | VM_MIXEDMAP | VM_SAO) +static inline int ckpt_validate_errno (int errno) {return (errno >=0 ) && (errno <MAX_ERRNO );
@@ -160,6 +192,8 @@ static inline int ckpt_validate_errno(int errno)#define CKPT_DRW 0x4/* image read/write */ #define CKPT_DOBJ 0x8/* shared objects */ #define CKPT_DFILE 0x10/* files and filesystem */ +#define CKPT_DMEM 0x20/* memory state */ +#define CKPT_DPAGE 0x40/* memory pages */ #define CKPT_DDEFAULT 0xffff/* default debug level */
include/linux/checkpoint_hdr.h +62 -0
90 lines not on this page · raw message
include/linux/checkpoint_types.h +21 -0
@@ -15,6 +15,8 @@#include <linux/sched.h> #include <linux/nsproxy.h> #include <linux/list.h> +#include <linux/sched.h> +#include <linux/nsproxy.h> #include <linux/path.h> #include <linux/fs.h>
@@ -46,6 +48,25 @@ struct ckpt_ctx {int errno;/* errno that caused failure */ +struct completion errno_sync;/* protect errno setting */ + +struct list_head pgarr_list;/* page array to dump VMA contents */ +struct list_head pgarr_pool;/* pool of empty page arrays chain */ + +void *scratch_page;/* scratch buffer for page I/O */ + +/* [multi-process checkpoint] */ +struct task_struct **tasks_arr;/* array of all tasks [checkpoint] */ +int nr_tasks;/* size of tasks array */ + +/* [multi-process restart] */ +struct ckpt_pids *pids_arr;/* array of all pids [restart] */ +int nr_pids;/* size of pids array */ +atomic_t nr_total;/* total tasks count */ +int active_pid;/* (next) position in pids array */ +struct completion complete;/* container root and other tasks on */ +wait_queue_head_t waitq;/* start, end, and restart ordering */ +#define CKPT_MSG_LEN 1024char fmt[CKPT_MSG_LEN ];char msg[CKPT_MSG_LEN ];
include/linux/mm.h +19 -0
@@ -1324,9 +1324,13 @@ out: }extern int do_munmap (struct mm_struct *,unsigned long ,size_t ); +extern int destroy_mm (struct mm_struct *);extern unsigned long do_brk (unsigned long ,unsigned long ); +/* fs/exec.c */ +extern int exec_mmap (struct mm_struct *mm); +/* filemap.c */ extern unsigned long page_unuse (struct page *);extern void truncate_inode_pages (struct address_space *,loff_t );
@@ -1336,10 +1340,25 @@ extern void truncate_inode_pages_range(struct address_space *,/* generic vm_area_ops exported for stackable file systems */ extern int filemap_fault (struct vm_area_struct *,struct vm_fault *); +#ifdef CONFIG_CHECKPOINT +/* generic vm_area_ops exported for mapped files checkpoint */ +extern int filemap_checkpoint (struct ckpt_ctx *,struct vm_area_struct *); +#endif +/* mm/page-writeback.c */ int write_one_page (struct page *page,int wait);void task_dirty_inc (struct task_struct *tsk); + +/* checkpoint/restart */ +#ifdef CONFIG_CHECKPOINT +struct ckpt_hdr_vma ; +extern int filemap_restore (struct ckpt_ctx *ctx,struct mm_struct *mm, +struct ckpt_hdr_vma *hh); +extern int special_mapping_restore (struct ckpt_ctx *ctx,struct mm_struct *mm, +struct ckpt_hdr_vma *hh); +#endif +/* readahead.c */ #define VM_MAX_READAHEAD 128/* kbytes */ #define VM_MIN_READAHEAD 16/* kbytes (includes current page) */
kernel/checkpoint/checkpoint.c +2 -0
@@ -109,6 +109,8 @@ static void fill_kernel_const(struct ckpt_const *h)/* task */ h->task_comm_len =sizeof (tsk->comm); +/* mm->saved_auxv size */ + h->at_vector_size =AT_VECTOR_SIZE ;/* uts */ h->uts_release_len =sizeof (uts->release); h->uts_version_len =sizeof (uts->version);
kernel/checkpoint/process.c +12 -0
@@ -51,6 +51,7 @@ static int checkpoint_task_objs(struct ckpt_ctx *ctx, struct task_struct *t) {struct ckpt_hdr_task_objs *h;int files_objref; +int mm_objref;int ret; files_objref =checkpoint_obj_file_table (ctx, t);
@@ -60,10 +61,18 @@ static int checkpoint_task_objs(struct ckpt_ctx *ctx, struct task_struct *t)return files_objref; } + mm_objref =checkpoint_obj_mm (ctx, t); +ckpt_debug ("mm: objref %d\n" , mm_objref); +if (mm_objref <0 ) { +ckpt_err (ctx, mm_objref,"%(T)mm_struct\n" ); +return mm_objref; + } + h =ckpt_hdr_get_type (ctx,sizeof (*h),CKPT_HDR_TASK_OBJS );if (!h)return -ENOMEM ; h->files_objref = files_objref; + h->mm_objref = mm_objref; ret =ckpt_write_obj (ctx, &h->h);ckpt_hdr_put (ctx, h);
@@ -137,6 +146,9 @@ static int restore_task_objs(struct ckpt_ctx *ctx) ret =restore_obj_file_table (ctx, h->files_objref);ckpt_debug ("file_table: ret %d (%p)\n" , ret, current->files); + ret =restore_obj_mm (ctx, h->mm_objref); +ckpt_debug ("mm: ret %d (%p)\n" , ret, current->mm); +ckpt_hdr_put (ctx, h);return ret; }
kernel/checkpoint/restart.c +3 -0
@@ -400,6 +400,9 @@ static int check_kernel_const(struct ckpt_const *h)/* task */ if (h->task_comm_len !=sizeof (tsk->comm))return -EINVAL ; +/* mm->saved_auxv size */ +if (h->at_vector_size !=AT_VECTOR_SIZE ) +return -EINVAL ;/* uts */ if (h->uts_release_len !=sizeof (uts->release))return -EINVAL ;
kernel/checkpoint/sys.c +17 -0
@@ -172,6 +172,7 @@ static void ckpt_ctx_free(struct ckpt_ctx *ctx)ckpt_obj_hash_free (ctx);path_put (&ctx->root_fs_path); +ckpt_pgarr_free (ctx);if (ctx->root_nsproxy)put_nsproxy (ctx->root_nsproxy);
@@ -180,6 +181,10 @@ static void ckpt_ctx_free(struct ckpt_ctx *ctx)if (ctx->root_freezer)put_task_struct (ctx->root_freezer); +free_page ((unsigned long ) ctx->scratch_page); + +kfree (ctx->pids_arr); +kfree (ctx); }
@@ -196,6 +201,14 @@ static struct ckpt_ctx *ckpt_ctx_alloc(int fd, unsigned long uflags, ctx->uflags = uflags; ctx->kflags = kflags; +atomic_set (&ctx->refcount,0 ); +INIT_LIST_HEAD (&ctx->pgarr_list); +INIT_LIST_HEAD (&ctx->pgarr_pool); +init_waitqueue_head (&ctx->waitq); +init_completion (&ctx->complete); + +init_completion (&ctx->errno_sync); +mutex_init (&ctx->msg_mutex); err = -EBADF ;
@@ -217,6 +230,10 @@ static struct ckpt_ctx *ckpt_ctx_alloc(int fd, unsigned long uflags,if (!ctx->files_deferq) goto err; + ctx->scratch_page = (void *)__get_free_page (GFP_KERNEL ); +if (!ctx->scratch_page) + goto err; +atomic_inc (&ctx->refcount);return ctx; err:
mm/Makefile +6 -0
@@ -36,6 +36,12 @@ obj-$(CONFIG_FAILSLAB) += failslab.o obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o obj-$(CONFIG_FS_XIP) += filemap_xip.o obj-$(CONFIG_MIGRATION) += migrate.o +ifdef CONFIG_SMP +obj-y += percpu.o +else +obj-y += percpu_up.o +endif +obj-$(CONFIG_CHECKPOINT) += checkpoint.o obj-$(CONFIG_QUICKLIST) += quicklist.o obj-$(CONFIG_CGROUP_MEM_RES_CTLR) += memcontrol.o page_cgroup.o obj-$(CONFIG_MEMORY_FAILURE) += memory-failure.o
mm/checkpoint.c new file +1159 -0
1,159 lines not on this page · raw message
mm/filemap.c +45 -0
59 lines not on this page · raw message
mm/mmap.c +96 -5
140 lines not on this page · raw message
Signature · 8 lines
1.7.2.2 -- To unsubscribe, send a message with 'unsubscribe linux-mm' in the body to [email protected]. For more info on Linux MM, see: http://www.linux-mm.org/ . Fight unfair telecom policy in Canada: sign http://dissolvethecrtc.ca/ Don't email: <a href=mailto:"[email protected]"> [email protected] </a>
PATCH 18/19 c/r: add generic '->checkpoint' f_op to ext fses
In reply to Dan SmithFrom: Dave Hansen <[email protected]>
This marks ext[234] as being checkpointable. There will be many more to do this to, but this is a start.
Changelog[ckpt-v21]:
- Put file_ops->checkpoint under CONFIG_CHECKPOINT
Changelog[ckpt-v19-rc3]:
- Rebase to kernel 2.6.33 (ext2)
Changelog[v1]:
- [Serge Hallyn] Use filemap_checkpoint() in ext4_file_vm_ops
--- fs/ext2/dir.c | 3 +++ fs/ext2/file.c | 6 ++++++ fs/ext3/dir.c | 3 +++ fs/ext3/file.c | 3 +++ fs/ext4/dir.c | 3 +++ fs/ext4/file.c | 6 ++++++ 6 files changed, 24 insertions(+), 0 deletions(-)
fs/ext2/dir.c +3 -0
@@ -721,4 +721,7 @@ const struct file_operations ext2_dir_operations = { .compat_ioctl = ext2_compat_ioctl, #endif .fsync = ext2_fsync, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };
fs/ext2/file.c +6 -0
@@ -76,6 +76,9 @@ const struct file_operations ext2_file_operations = { .fsync = ext2_fsync, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif /* CONFIG_CHECKPOINT */ };#ifdef CONFIG_EXT2_FS_XIP
@@ -91,6 +94,9 @@ const struct file_operations ext2_xip_file_operations = { .open = dquot_file_open, .release = ext2_release_file, .fsync = ext2_fsync, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif /* CONFIG_CHECKPOINT */ };#endif
fs/ext3/dir.c +3 -0
@@ -48,6 +48,9 @@ const struct file_operations ext3_dir_operations = {#endif .fsync = ext3_sync_file, /* BKL held */ .release = ext3_release_dir, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };
fs/ext3/file.c +3 -0
@@ -68,6 +68,9 @@ const struct file_operations ext3_file_operations = { .fsync = ext3_sync_file, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };const struct inode_operations ext3_file_inode_operations = {
fs/ext4/dir.c +3 -0
@@ -48,6 +48,9 @@ const struct file_operations ext4_dir_operations = {#endif .fsync = ext4_sync_file, .release = ext4_release_dir, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };
fs/ext4/file.c +6 -0
@@ -86,6 +86,9 @@ ext4_file_write(struct kiocb *iocb, const struct iovec *iov,static const struct vm_operations_struct ext4_file_vm_ops = { .fault = filemap_fault, .page_mkwrite = ext4_page_mkwrite, +#ifdef CONFIG_CHECKPOINT + .checkpoint = filemap_checkpoint, +#endif };static int ext4_file_mmap (struct file *file,struct vm_area_struct *vma)
@@ -188,6 +191,9 @@ const struct file_operations ext4_file_operations = { .fsync = ext4_sync_file, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };const struct inode_operations ext4_file_inode_operations = {
Signature · 1 line
1.7.2.2
Re: [PATCH 18/19] c/r: add generic '->checkpoint' f_op to ext fses
DS> Cc: [email protected]
Please ignore this patch, I did not mean to send it out.
Signature · 3 lines
Dan Smith IBM Linux Technology Center email: [email protected]
PATCH 19/19 c/r: add generic '->checkpoint()' f_op to simple devices
In reply to Dan SmithFrom: Oren Laadan <[email protected]>
* /dev/null
* /dev/zero
* /dev/random
* /dev/urandom
Changelog [v21]:
- Put file_ops->checkpoint under CONFIG_CHECKPOINT
--- drivers/char/mem.c | 6 ++++++ drivers/char/random.c | 6 ++++++ 2 files changed, 12 insertions(+), 0 deletions(-)
drivers/char/mem.c +6 -0
@@ -767,6 +767,9 @@ static const struct file_operations null_fops = { .read = read_null, .write = write_null, .splice_write = splice_write_null, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };#ifdef CONFIG_DEVPORT
@@ -783,6 +786,9 @@ static const struct file_operations zero_fops = { .read = read_zero, .write = write_zero, .mmap = mmap_zero, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };/*
drivers/char/random.c +6 -0
@@ -1166,6 +1166,9 @@ const struct file_operations random_fops = { .unlocked_ioctl = random_ioctl, .fasync = random_fasync, .llseek = noop_llseek, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };const struct file_operations urandom_fops = {
@@ -1174,6 +1177,9 @@ const struct file_operations urandom_fops = { .unlocked_ioctl = random_ioctl, .fasync = random_fasync, .llseek = noop_llseek, +#ifdef CONFIG_CHECKPOINT + .checkpoint = generic_file_checkpoint, +#endif };/***************************************************************
Signature · 1 line
1.7.2.2