Merge branch 'linus' into sched/core

Conflicts:
	fs/proc/array.c

Merge reason: resolve conflict and queue up dependent patch.

Signed-off-by: Ingo Molnar <mingo@elte.hu>

9 files changed, 485 insertions, 99 deletions

diff --git a/fs/proc/array.c b/fs/proc/array.c
index 762aea9c9c71..e209f64ab27b 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -82,6 +82,7 @@
 #include <linux/pid_namespace.h>
 #include <linux/ptrace.h>
 #include <linux/tracehook.h>
+#include <linux/swapops.h>
 
 #include <asm/pgtable.h>
 #include <asm/processor.h>
@@ -321,6 +322,94 @@ static inline void task_context_switch_counts(struct seq_file *m,
                         p->nivcsw);
 }
 
+#ifdef CONFIG_MMU
+
+struct stack_stats {
+        struct vm_area_struct *vma;
+        unsigned long   startpage;
+        unsigned long   usage;
+};
+
+static int stack_usage_pte_range(pmd_t *pmd, unsigned long addr,
+                                unsigned long end, struct mm_walk *walk)
+{
+        struct stack_stats *ss = walk->private;
+        struct vm_area_struct *vma = ss->vma;
+        pte_t *pte, ptent;
+        spinlock_t *ptl;
+        int ret = 0;
+
+        pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
+        for (; addr != end; pte++, addr += PAGE_SIZE) {
+                ptent = *pte;
+
+#ifdef CONFIG_STACK_GROWSUP
+                if (pte_present(ptent) || is_swap_pte(ptent))
+                        ss->usage = addr - ss->startpage + PAGE_SIZE;
+#else
+                if (pte_present(ptent) || is_swap_pte(ptent)) {
+                        ss->usage = ss->startpage - addr + PAGE_SIZE;
+                        pte++;
+                        ret = 1;
+                        break;
+                }
+#endif
+        }
+        pte_unmap_unlock(pte - 1, ptl);
+        cond_resched();
+        return ret;
+}
+
+static inline unsigned long get_stack_usage_in_bytes(struct vm_area_struct *vma,
+                                struct task_struct *task)
+{
+        struct stack_stats ss;
+        struct mm_walk stack_walk = {
+                .pmd_entry = stack_usage_pte_range,
+                .mm = vma->vm_mm,
+                .private = &ss,
+        };
+
+        if (!vma->vm_mm || is_vm_hugetlb_page(vma))
+                return 0;
+
+        ss.vma = vma;
+        ss.startpage = task->stack_start & PAGE_MASK;
+        ss.usage = 0;
+
+#ifdef CONFIG_STACK_GROWSUP
+        walk_page_range(KSTK_ESP(task) & PAGE_MASK, vma->vm_end,
+                &stack_walk);
+#else
+        walk_page_range(vma->vm_start, (KSTK_ESP(task) & PAGE_MASK) + PAGE_SIZE,
+                &stack_walk);
+#endif
+        return ss.usage;
+}
+
+static inline void task_show_stack_usage(struct seq_file *m,
+                                                struct task_struct *task)
+{
+        struct vm_area_struct   *vma;
+        struct mm_struct        *mm = get_task_mm(task);
+
+        if (mm) {
+                down_read(&mm->mmap_sem);
+                vma = find_vma(mm, task->stack_start);
+                if (vma)
+                        seq_printf(m, "Stack usage:\t%lu kB\n",
+                                get_stack_usage_in_bytes(vma, task) >> 10);
+
+                up_read(&mm->mmap_sem);
+                mmput(mm);
+        }
+}
+#else
+static void task_show_stack_usage(struct seq_file *m, struct task_struct *task)
+{
+}
+#endif          /* CONFIG_MMU */
+
 static void task_cpus_allowed(struct seq_file *m, struct task_struct *task)
 {
         seq_printf(m, "Cpus_allowed:\t");
@@ -351,6 +440,7 @@ int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
         task_show_regs(m, task);
 #endif
         task_context_switch_counts(m, task);
+        task_show_stack_usage(m, task);
         return 0;
 }
 
@@ -492,7 +582,7 @@ static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
                 rsslim,
                 mm ? mm->start_code : 0,
                 mm ? mm->end_code : 0,
-                (permitted && mm) ? mm->start_stack : 0,
+                (permitted) ? task->stack_start : 0,
                 esp,
                 eip,
                 /* The signal information here is obsolete.
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 6f742f6658a9..837469a96598 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -447,7 +447,7 @@ static int proc_oom_score(struct task_struct *task, char *buffer)
 
         do_posix_clock_monotonic_gettime(&uptime);
         read_lock(&tasklist_lock);
-        points = badness(task, uptime.tv_sec);
+        points = badness(task->group_leader, uptime.tv_sec);
         read_unlock(&tasklist_lock);
         return sprintf(buffer, "%lu\n", points);
 }
@@ -458,7 +458,7 @@ struct limit_names {
 };
 
 static const struct limit_names lnames[RLIM_NLIMITS] = {
-        [RLIMIT_CPU] = {"Max cpu time", "ms"},
+        [RLIMIT_CPU] = {"Max cpu time", "seconds"},
         [RLIMIT_FSIZE] = {"Max file size", "bytes"},
         [RLIMIT_DATA] = {"Max data size", "bytes"},
         [RLIMIT_STACK] = {"Max stack size", "bytes"},
@@ -999,11 +999,17 @@ static ssize_t oom_adjust_read(struct file *file, char __user *buf,
         struct task_struct *task = get_proc_task(file->f_path.dentry->d_inode);
         char buffer[PROC_NUMBUF];
         size_t len;
-        int oom_adjust;
+        int oom_adjust = OOM_DISABLE;
+        unsigned long flags;
 
         if (!task)
                 return -ESRCH;
-        oom_adjust = task->oomkilladj;
+
+        if (lock_task_sighand(task, &flags)) {
+                oom_adjust = task->signal->oom_adj;
+                unlock_task_sighand(task, &flags);
+        }
+
         put_task_struct(task);
 
         len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
@@ -1015,32 +1021,44 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         struct task_struct *task;
-        char buffer[PROC_NUMBUF], *end;
-        int oom_adjust;
+        char buffer[PROC_NUMBUF];
+        long oom_adjust;
+        unsigned long flags;
+        int err;
 
         memset(buffer, 0, sizeof(buffer));
         if (count > sizeof(buffer) - 1)
                 count = sizeof(buffer) - 1;
         if (copy_from_user(buffer, buf, count))
                 return -EFAULT;
-        oom_adjust = simple_strtol(buffer, &end, 0);
+
+        err = strict_strtol(strstrip(buffer), 0, &oom_adjust);
+        if (err)
+                return -EINVAL;
         if ((oom_adjust < OOM_ADJUST_MIN || oom_adjust > OOM_ADJUST_MAX) &&
              oom_adjust != OOM_DISABLE)
                 return -EINVAL;
-        if (*end == '\n')
-                end++;
+
         task = get_proc_task(file->f_path.dentry->d_inode);
         if (!task)
                 return -ESRCH;
-        if (oom_adjust < task->oomkilladj && !capable(CAP_SYS_RESOURCE)) {
+        if (!lock_task_sighand(task, &flags)) {
+                put_task_struct(task);
+                return -ESRCH;
+        }
+
+        if (oom_adjust < task->signal->oom_adj && !capable(CAP_SYS_RESOURCE)) {
+                unlock_task_sighand(task, &flags);
                 put_task_struct(task);
                 return -EACCES;
         }
-        task->oomkilladj = oom_adjust;
+
+        task->signal->oom_adj = oom_adjust;
+
+        unlock_task_sighand(task, &flags);
         put_task_struct(task);
-        if (end - buffer == 0)
-                return -EIO;
-        return end - buffer;
+
+        return count;
 }
 
 static const struct file_operations proc_oom_adjust_operations = {
@@ -1169,17 +1187,16 @@ static ssize_t proc_fault_inject_write(struct file * file,
                 count = sizeof(buffer) - 1;
         if (copy_from_user(buffer, buf, count))
                 return -EFAULT;
-        make_it_fail = simple_strtol(buffer, &end, 0);
-        if (*end == '\n')
-                end++;
+        make_it_fail = simple_strtol(strstrip(buffer), &end, 0);
+        if (*end)
+                return -EINVAL;
         task = get_proc_task(file->f_dentry->d_inode);
         if (!task)
                 return -ESRCH;
         task->make_it_fail = make_it_fail;
         put_task_struct(task);
-        if (end - buffer == 0)
-                return -EIO;
-        return end - buffer;
+
+        return count;
 }
 
 static const struct file_operations proc_fault_inject_operations = {
@@ -2586,9 +2603,6 @@ static void proc_flush_task_mnt(struct vfsmount *mnt, pid_t pid, pid_t tgid)
                 dput(dentry);
         }
 
-        if (tgid == 0)
-                goto out;
-
         name.name = buf;
         name.len = snprintf(buf, sizeof(buf), "%d", tgid);
         leader = d_hash_and_lookup(mnt->mnt_root, &name);
@@ -2645,17 +2659,16 @@ out:
 void proc_flush_task(struct task_struct *task)
 {
         int i;
-        struct pid *pid, *tgid = NULL;
+        struct pid *pid, *tgid;
         struct upid *upid;
 
         pid = task_pid(task);
-        if (thread_group_leader(task))
-                tgid = task_tgid(task);
+        tgid = task_tgid(task);
 
         for (i = 0; i <= pid->level; i++) {
                 upid = &pid->numbers[i];
                 proc_flush_task_mnt(upid->ns->proc_mnt, upid->nr,
-                        tgid ? tgid->numbers[i].nr : 0);
+                                        tgid->numbers[i].nr);
         }
 
         upid = &pid->numbers[pid->level];
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 59b43a068872..a44a7897fd4d 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -17,9 +17,14 @@
 #include <linux/elfcore.h>
 #include <linux/vmalloc.h>
 #include <linux/highmem.h>
+#include <linux/bootmem.h>
 #include <linux/init.h>
 #include <asm/uaccess.h>
 #include <asm/io.h>
+#include <linux/list.h>
+#include <linux/ioport.h>
+#include <linux/memory.h>
+#include <asm/sections.h>
 
 #define CORE_STR "CORE"
 
@@ -29,17 +34,6 @@
 
 static struct proc_dir_entry *proc_root_kcore;
 
-static int open_kcore(struct inode * inode, struct file * filp)
-{
-        return capable(CAP_SYS_RAWIO) ? 0 : -EPERM;
-}
-
-static ssize_t read_kcore(struct file *, char __user *, size_t, loff_t *);
-
-static const struct file_operations proc_kcore_operations = {
-        .read           = read_kcore,
-        .open           = open_kcore,
-};
 
 #ifndef kc_vaddr_to_offset
 #define kc_vaddr_to_offset(v) ((v) - PAGE_OFFSET)
@@ -57,18 +51,19 @@ struct memelfnote
         void *data;
 };
 
-static struct kcore_list *kclist;
+static LIST_HEAD(kclist_head);
 static DEFINE_RWLOCK(kclist_lock);
+static int kcore_need_update = 1;
 
 void
-kclist_add(struct kcore_list *new, void *addr, size_t size)
+kclist_add(struct kcore_list *new, void *addr, size_t size, int type)
 {
         new->addr = (unsigned long)addr;
         new->size = size;
+        new->type = type;
 
         write_lock(&kclist_lock);
-        new->next = kclist;
-        kclist = new;
+        list_add_tail(&new->list, &kclist_head);
         write_unlock(&kclist_lock);
 }
 
@@ -80,7 +75,7 @@ static size_t get_kcore_size(int *nphdr, size_t *elf_buflen)
         *nphdr = 1; /* PT_NOTE */
         size = 0;
 
-        for (m=kclist; m; m=m->next) {
+        list_for_each_entry(m, &kclist_head, list) {
                 try = kc_vaddr_to_offset((size_t)m->addr + m->size);
                 if (try > size)
                         size = try;
@@ -97,6 +92,177 @@ static size_t get_kcore_size(int *nphdr, size_t *elf_buflen)
         return size + *elf_buflen;
 }
 
+static void free_kclist_ents(struct list_head *head)
+{
+        struct kcore_list *tmp, *pos;
+
+        list_for_each_entry_safe(pos, tmp, head, list) {
+                list_del(&pos->list);
+                kfree(pos);
+        }
+}
+/*
+ * Replace all KCORE_RAM/KCORE_VMEMMAP information with passed list.
+ */
+static void __kcore_update_ram(struct list_head *list)
+{
+        int nphdr;
+        size_t size;
+        struct kcore_list *tmp, *pos;
+        LIST_HEAD(garbage);
+
+        write_lock(&kclist_lock);
+        if (kcore_need_update) {
+                list_for_each_entry_safe(pos, tmp, &kclist_head, list) {
+                        if (pos->type == KCORE_RAM
+                                || pos->type == KCORE_VMEMMAP)
+                                list_move(&pos->list, &garbage);
+                }
+                list_splice_tail(list, &kclist_head);
+        } else
+                list_splice(list, &garbage);
+        kcore_need_update = 0;
+        proc_root_kcore->size = get_kcore_size(&nphdr, &size);
+        write_unlock(&kclist_lock);
+
+        free_kclist_ents(&garbage);
+}
+
+
+#ifdef CONFIG_HIGHMEM
+/*
+ * If no highmem, we can assume [0...max_low_pfn) continuous range of memory
+ * because memory hole is not as big as !HIGHMEM case.
+ * (HIGHMEM is special because part of memory is _invisible_ from the kernel.)
+ */
+static int kcore_update_ram(void)
+{
+        LIST_HEAD(head);
+        struct kcore_list *ent;
+        int ret = 0;
+
+        ent = kmalloc(sizeof(*ent), GFP_KERNEL);
+        if (!ent)
+                return -ENOMEM;
+        ent->addr = (unsigned long)__va(0);
+        ent->size = max_low_pfn << PAGE_SHIFT;
+        ent->type = KCORE_RAM;
+        list_add(&ent->list, &head);
+        __kcore_update_ram(&head);
+        return ret;
+}
+
+#else /* !CONFIG_HIGHMEM */
+
+#ifdef CONFIG_SPARSEMEM_VMEMMAP
+/* calculate vmemmap's address from given system ram pfn and register it */
+int get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
+{
+        unsigned long pfn = __pa(ent->addr) >> PAGE_SHIFT;
+        unsigned long nr_pages = ent->size >> PAGE_SHIFT;
+        unsigned long start, end;
+        struct kcore_list *vmm, *tmp;
+
+
+        start = ((unsigned long)pfn_to_page(pfn)) & PAGE_MASK;
+        end = ((unsigned long)pfn_to_page(pfn + nr_pages)) - 1;
+        end = ALIGN(end, PAGE_SIZE);
+        /* overlap check (because we have to align page */
+        list_for_each_entry(tmp, head, list) {
+                if (tmp->type != KCORE_VMEMMAP)
+                        continue;
+                if (start < tmp->addr + tmp->size)
+                        if (end > tmp->addr)
+                                end = tmp->addr;
+        }
+        if (start < end) {
+                vmm = kmalloc(sizeof(*vmm), GFP_KERNEL);
+                if (!vmm)
+                        return 0;
+                vmm->addr = start;
+                vmm->size = end - start;
+                vmm->type = KCORE_VMEMMAP;
+                list_add_tail(&vmm->list, head);
+        }
+        return 1;
+
+}
+#else
+int get_sparsemem_vmemmap_info(struct kcore_list *ent, struct list_head *head)
+{
+        return 1;
+}
+
+#endif
+
+static int
+kclist_add_private(unsigned long pfn, unsigned long nr_pages, void *arg)
+{
+        struct list_head *head = (struct list_head *)arg;
+        struct kcore_list *ent;
+
+        ent = kmalloc(sizeof(*ent), GFP_KERNEL);
+        if (!ent)
+                return -ENOMEM;
+        ent->addr = (unsigned long)__va((pfn << PAGE_SHIFT));
+        ent->size = nr_pages << PAGE_SHIFT;
+
+        /* Sanity check: Can happen in 32bit arch...maybe */
+        if (ent->addr < (unsigned long) __va(0))
+                goto free_out;
+
+        /* cut not-mapped area. ....from ppc-32 code. */
+        if (ULONG_MAX - ent->addr < ent->size)
+                ent->size = ULONG_MAX - ent->addr;
+
+        /* cut when vmalloc() area is higher than direct-map area */
+        if (VMALLOC_START > (unsigned long)__va(0)) {
+                if (ent->addr > VMALLOC_START)
+                        goto free_out;
+                if (VMALLOC_START - ent->addr < ent->size)
+                        ent->size = VMALLOC_START - ent->addr;
+        }
+
+        ent->type = KCORE_RAM;
+        list_add_tail(&ent->list, head);
+
+        if (!get_sparsemem_vmemmap_info(ent, head)) {
+                list_del(&ent->list);
+                goto free_out;
+        }
+
+        return 0;
+free_out:
+        kfree(ent);
+        return 1;
+}
+
+static int kcore_update_ram(void)
+{
+        int nid, ret;
+        unsigned long end_pfn;
+        LIST_HEAD(head);
+
+        /* Not inialized....update now */
+        /* find out "max pfn" */
+        end_pfn = 0;
+        for_each_node_state(nid, N_HIGH_MEMORY) {
+                unsigned long node_end;
+                node_end  = NODE_DATA(nid)->node_start_pfn +
+                        NODE_DATA(nid)->node_spanned_pages;
+                if (end_pfn < node_end)
+                        end_pfn = node_end;
+        }
+        /* scan 0 to max_pfn */
+        ret = walk_system_ram_range(0, end_pfn, &head, kclist_add_private);
+        if (ret) {
+                free_kclist_ents(&head);
+                return -ENOMEM;
+        }
+        __kcore_update_ram(&head);
+        return ret;
+}
+#endif /* CONFIG_HIGHMEM */
 
 /*****************************************************************************/
 /*
@@ -192,7 +358,7 @@ static void elf_kcore_store_hdr(char *bufp, int nphdr, int dataoff)
         nhdr->p_align   = 0;
 
         /* setup ELF PT_LOAD program header for every area */
-        for (m=kclist; m; m=m->next) {
+        list_for_each_entry(m, &kclist_head, list) {
                 phdr = (struct elf_phdr *) bufp;
                 bufp += sizeof(struct elf_phdr);
                 offset += sizeof(struct elf_phdr);
@@ -265,7 +431,8 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)
         unsigned long start;
 
         read_lock(&kclist_lock);
-        proc_root_kcore->size = size = get_kcore_size(&nphdr, &elf_buflen);
+        size = get_kcore_size(&nphdr, &elf_buflen);
+
         if (buflen == 0 || *fpos >= size) {
                 read_unlock(&kclist_lock);
                 return 0;
@@ -317,7 +484,7 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)
                 struct kcore_list *m;
 
                 read_lock(&kclist_lock);
-                for (m=kclist; m; m=m->next) {
+                list_for_each_entry(m, &kclist_head, list) {
                         if (start >= m->addr && start < (m->addr+m->size))
                                 break;
                 }
@@ -326,45 +493,14 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)
                 if (m == NULL) {
                         if (clear_user(buffer, tsz))
                                 return -EFAULT;
-                } else if (is_vmalloc_addr((void *)start)) {
+                } else if (is_vmalloc_or_module_addr((void *)start)) {
                         char * elf_buf;
-                        struct vm_struct *m;
-                        unsigned long curstart = start;
-                        unsigned long cursize = tsz;
 
                         elf_buf = kzalloc(tsz, GFP_KERNEL);
                         if (!elf_buf)
                                 return -ENOMEM;
-
-                        read_lock(&vmlist_lock);
-                        for (m=vmlist; m && cursize; m=m->next) {
-                                unsigned long vmstart;
-                                unsigned long vmsize;
-                                unsigned long msize = m->size - PAGE_SIZE;
-
-                                if (((unsigned long)m->addr + msize) < 
-                                                                curstart)
-                                        continue;
-                                if ((unsigned long)m->addr > (curstart + 
-                                                                cursize))
-                                        break;
-                                vmstart = (curstart < (unsigned long)m->addr ? 
-                                        (unsigned long)m->addr : curstart);
-                                if (((unsigned long)m->addr + msize) > 
-                                                        (curstart + cursize))
-                                        vmsize = curstart + cursize - vmstart;
-                                else
-                                        vmsize = (unsigned long)m->addr + 
-                                                        msize - vmstart;
-                                curstart = vmstart + vmsize;
-                                cursize -= vmsize;
-                                /* don't dump ioremap'd stuff! (TA) */
-                                if (m->flags & VM_IOREMAP)
-                                        continue;
-                                memcpy(elf_buf + (vmstart - start),
-                                        (char *)vmstart, vmsize);
-                        }
-                        read_unlock(&vmlist_lock);
+                        vread(elf_buf, (char *)start, tsz);
+                        /* we have to zero-fill user buffer even if no read */
                         if (copy_to_user(buffer, elf_buf, tsz)) {
                                 kfree(elf_buf);
                                 return -EFAULT;
@@ -402,12 +538,96 @@ read_kcore(struct file *file, char __user *buffer, size_t buflen, loff_t *fpos)
         return acc;
 }
 
+
+static int open_kcore(struct inode *inode, struct file *filp)
+{
+        if (!capable(CAP_SYS_RAWIO))
+                return -EPERM;
+        if (kcore_need_update)
+                kcore_update_ram();
+        if (i_size_read(inode) != proc_root_kcore->size) {
+                mutex_lock(&inode->i_mutex);
+                i_size_write(inode, proc_root_kcore->size);
+                mutex_unlock(&inode->i_mutex);
+        }
+        return 0;
+}
+
+
+static const struct file_operations proc_kcore_operations = {
+        .read           = read_kcore,
+        .open           = open_kcore,
+};
+
+#ifdef CONFIG_MEMORY_HOTPLUG
+/* just remember that we have to update kcore */
+static int __meminit kcore_callback(struct notifier_block *self,
+                                    unsigned long action, void *arg)
+{
+        switch (action) {
+        case MEM_ONLINE:
+        case MEM_OFFLINE:
+                write_lock(&kclist_lock);
+                kcore_need_update = 1;
+                write_unlock(&kclist_lock);
+        }
+        return NOTIFY_OK;
+}
+#endif
+
+
+static struct kcore_list kcore_vmalloc;
+
+#ifdef CONFIG_ARCH_PROC_KCORE_TEXT
+static struct kcore_list kcore_text;
+/*
+ * If defined, special segment is used for mapping kernel text instead of
+ * direct-map area. We need to create special TEXT section.
+ */
+static void __init proc_kcore_text_init(void)
+{
+        kclist_add(&kcore_text, _stext, _end - _stext, KCORE_TEXT);
+}
+#else
+static void __init proc_kcore_text_init(void)
+{
+}
+#endif
+
+#if defined(CONFIG_MODULES) && defined(MODULES_VADDR)
+/*
+ * MODULES_VADDR has no intersection with VMALLOC_ADDR.
+ */
+struct kcore_list kcore_modules;
+static void __init add_modules_range(void)
+{
+        kclist_add(&kcore_modules, (void *)MODULES_VADDR,
+                        MODULES_END - MODULES_VADDR, KCORE_VMALLOC);
+}
+#else
+static void __init add_modules_range(void)
+{
+}
+#endif
+
 static int __init proc_kcore_init(void)
 {
-        proc_root_kcore = proc_create("kcore", S_IRUSR, NULL, &proc_kcore_operations);
-        if (proc_root_kcore)
-                proc_root_kcore->size =
-                                (size_t)high_memory - PAGE_OFFSET + PAGE_SIZE;
+        proc_root_kcore = proc_create("kcore", S_IRUSR, NULL,
+                                      &proc_kcore_operations);
+        if (!proc_root_kcore) {
+                printk(KERN_ERR "couldn't create /proc/kcore\n");
+                return 0; /* Always returns 0. */
+        }
+        /* Store text area if it's special */
+        proc_kcore_text_init();
+        /* Store vmalloc area */
+        kclist_add(&kcore_vmalloc, (void *)VMALLOC_START,
+                VMALLOC_END - VMALLOC_START, KCORE_VMALLOC);
+        add_modules_range();
+        /* Store direct-map area from physical memory map */
+        kcore_update_ram();
+        hotplug_memory_notifier(kcore_callback, 0);
+
         return 0;
 }
 module_init(proc_kcore_init);
diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c
index d5c410d47fae..c7bff4f603ff 100644
--- a/fs/proc/meminfo.c
+++ b/fs/proc/meminfo.c
@@ -81,9 +81,11 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 "Writeback:      %8lu kB\n"
                 "AnonPages:      %8lu kB\n"
                 "Mapped:         %8lu kB\n"
+                "Shmem:          %8lu kB\n"
                 "Slab:           %8lu kB\n"
                 "SReclaimable:   %8lu kB\n"
                 "SUnreclaim:     %8lu kB\n"
+                "KernelStack:    %8lu kB\n"
                 "PageTables:     %8lu kB\n"
 #ifdef CONFIG_QUICKLIST
                 "Quicklists:     %8lu kB\n"
@@ -95,7 +97,11 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 "Committed_AS:   %8lu kB\n"
                 "VmallocTotal:   %8lu kB\n"
                 "VmallocUsed:    %8lu kB\n"
-                "VmallocChunk:   %8lu kB\n",
+                "VmallocChunk:   %8lu kB\n"
+#ifdef CONFIG_MEMORY_FAILURE
+                "HardwareCorrupted: %8lu kB\n"
+#endif
+                ,
                 K(i.totalram),
                 K(i.freeram),
                 K(i.bufferram),
@@ -124,10 +130,12 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 K(global_page_state(NR_WRITEBACK)),
                 K(global_page_state(NR_ANON_PAGES)),
                 K(global_page_state(NR_FILE_MAPPED)),
+                K(global_page_state(NR_SHMEM)),
                 K(global_page_state(NR_SLAB_RECLAIMABLE) +
                                 global_page_state(NR_SLAB_UNRECLAIMABLE)),
                 K(global_page_state(NR_SLAB_RECLAIMABLE)),
                 K(global_page_state(NR_SLAB_UNRECLAIMABLE)),
+                global_page_state(NR_KERNEL_STACK) * THREAD_SIZE / 1024,
                 K(global_page_state(NR_PAGETABLE)),
 #ifdef CONFIG_QUICKLIST
                 K(quicklist_total_size()),
@@ -140,6 +148,9 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 (unsigned long)VMALLOC_TOTAL >> 10,
                 vmi.used >> 10,
                 vmi.largest_chunk >> 10
+#ifdef CONFIG_MEMORY_FAILURE
+                ,atomic_long_read(&mce_bad_pages) << (PAGE_SHIFT - 10)
+#endif
                 );
 
         hugetlb_report_meminfo(m);
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index 7e14d1a04001..9fe7d7ebe115 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -109,7 +109,7 @@ static void *nommu_region_list_next(struct seq_file *m, void *v, loff_t *pos)
         return rb_next((struct rb_node *) v);
 }
 
-static struct seq_operations proc_nommu_region_list_seqop = {
+static const struct seq_operations proc_nommu_region_list_seqop = {
         .start  = nommu_region_list_start,
         .next   = nommu_region_list_next,
         .stop   = nommu_region_list_stop,
diff --git a/fs/proc/page.c b/fs/proc/page.c
index 2707c6c7a20f..5033ce0d254b 100644
--- a/fs/proc/page.c
+++ b/fs/proc/page.c
@@ -2,6 +2,7 @@
 #include <linux/compiler.h>
 #include <linux/fs.h>
 #include <linux/init.h>
+#include <linux/ksm.h>
 #include <linux/mm.h>
 #include <linux/mmzone.h>
 #include <linux/proc_fs.h>
@@ -93,8 +94,11 @@ static const struct file_operations proc_kpagecount_operations = {
 #define KPF_COMPOUND_TAIL       16
 #define KPF_HUGE                17
 #define KPF_UNEVICTABLE         18
+#define KPF_HWPOISON            19
 #define KPF_NOPAGE              20
 
+#define KPF_KSM                 21
+
 /* kernel hacking assistances
  * WARNING: subject to change, never rely on them!
  */
@@ -137,6 +141,8 @@ static u64 get_uflags(struct page *page)
                 u |= 1 << KPF_MMAP;
         if (PageAnon(page))
                 u |= 1 << KPF_ANON;
+        if (PageKsm(page))
+                u |= 1 << KPF_KSM;
 
         /*
          * compound pages: export both head/tail info
@@ -175,6 +181,10 @@ static u64 get_uflags(struct page *page)
         u |= kpf_copy_bit(k, KPF_UNEVICTABLE,   PG_unevictable);
         u |= kpf_copy_bit(k, KPF_MLOCKED,       PG_mlocked);
 
+#ifdef CONFIG_MEMORY_FAILURE
+        u |= kpf_copy_bit(k, KPF_HWPOISON,      PG_hwpoison);
+#endif
+
 #ifdef CONFIG_IA64_UNCACHED_ALLOCATOR
         u |= kpf_copy_bit(k, KPF_UNCACHED,      PG_uncached);
 #endif
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 9b1e4e9a16bf..f667e8aeabdf 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -153,7 +153,7 @@ static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
 
         /* careful: calling conventions are nasty here */
         res = count;
-        error = table->proc_handler(table, write, filp, buf, &res, ppos);
+        error = table->proc_handler(table, write, buf, &res, ppos);
         if (!error)
                 error = res;
 out:
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 9bd8be1d235c..2a1bef9203c6 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -243,6 +243,25 @@ static void show_map_vma(struct seq_file *m, struct vm_area_struct *vma)
                                 } else if (vma->vm_start <= mm->start_stack &&
                                            vma->vm_end >= mm->start_stack) {
                                         name = "[stack]";
+                                } else {
+                                        unsigned long stack_start;
+                                        struct proc_maps_private *pmp;
+
+                                        pmp = m->private;
+                                        stack_start = pmp->task->stack_start;
+
+                                        if (vma->vm_start <= stack_start &&
+                                            vma->vm_end >= stack_start) {
+                                                pad_len_spaces(m, len);
+                                                seq_printf(m,
+                                                 "[threadstack:%08lx]",
+#ifdef CONFIG_STACK_GROWSUP
+                                                 vma->vm_end - stack_start
+#else
+                                                 stack_start - vma->vm_start
+#endif
+                                                );
+                                        }
                                 }
                         } else {
                                 name = "[vdso]";
@@ -465,23 +484,28 @@ static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr,
         return 0;
 }
 
+#define CLEAR_REFS_ALL 1
+#define CLEAR_REFS_ANON 2
+#define CLEAR_REFS_MAPPED 3
+
 static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         struct task_struct *task;
-        char buffer[PROC_NUMBUF], *end;
+        char buffer[PROC_NUMBUF];
         struct mm_struct *mm;
         struct vm_area_struct *vma;
+        long type;
 
         memset(buffer, 0, sizeof(buffer));
         if (count > sizeof(buffer) - 1)
                 count = sizeof(buffer) - 1;
         if (copy_from_user(buffer, buf, count))
                 return -EFAULT;
-        if (!simple_strtol(buffer, &end, 0))
+        if (strict_strtol(strstrip(buffer), 10, &type))
+                return -EINVAL;
+        if (type < CLEAR_REFS_ALL || type > CLEAR_REFS_MAPPED)
                 return -EINVAL;
-        if (*end == '\n')
-                end++;
         task = get_proc_task(file->f_path.dentry->d_inode);
         if (!task)
                 return -ESRCH;
@@ -494,18 +518,31 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                 down_read(&mm->mmap_sem);
                 for (vma = mm->mmap; vma; vma = vma->vm_next) {
                         clear_refs_walk.private = vma;
-                        if (!is_vm_hugetlb_page(vma))
-                                walk_page_range(vma->vm_start, vma->vm_end,
-                                                &clear_refs_walk);
+                        if (is_vm_hugetlb_page(vma))
+                                continue;
+                        /*
+                         * Writing 1 to /proc/pid/clear_refs affects all pages.
+                         *
+                         * Writing 2 to /proc/pid/clear_refs only affects
+                         * Anonymous pages.
+                         *
+                         * Writing 3 to /proc/pid/clear_refs only affects file
+                         * mapped pages.
+                         */
+                        if (type == CLEAR_REFS_ANON && vma->vm_file)
+                                continue;
+                        if (type == CLEAR_REFS_MAPPED && !vma->vm_file)
+                                continue;
+                        walk_page_range(vma->vm_start, vma->vm_end,
+                                        &clear_refs_walk);
                 }
                 flush_tlb_mm(mm);
                 up_read(&mm->mmap_sem);
                 mmput(mm);
         }
         put_task_struct(task);
-        if (end - buffer == 0)
-                return -EIO;
-        return end - buffer;
+
+        return count;
 }
 
 const struct file_operations proc_clear_refs_operations = {
diff --git a/fs/proc/uptime.c b/fs/proc/uptime.c
index 0c10a0b3f146..766b1d456050 100644
--- a/fs/proc/uptime.c
+++ b/fs/proc/uptime.c
@@ -4,13 +4,18 @@
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/time.h>
+#include <linux/kernel_stat.h>
 #include <asm/cputime.h>
 
 static int uptime_proc_show(struct seq_file *m, void *v)
 {
         struct timespec uptime;
         struct timespec idle;
-        cputime_t idletime = cputime_add(init_task.utime, init_task.stime);
+        int i;
+        cputime_t idletime = cputime_zero;
+
+        for_each_possible_cpu(i)
+                idletime = cputime64_add(idletime, kstat_cpu(i).cpustat.idle);
 
         do_posix_clock_monotonic_gettime(&uptime);
         monotonic_to_bootbased(&uptime);