11 files changed, 162 insertions, 52 deletions

diff --git a/fs/proc/Kconfig b/fs/proc/Kconfig
index 15af6222f8a..ddb83a0e15e 100644
--- a/fs/proc/Kconfig
+++ b/fs/proc/Kconfig
@@ -67,3 +67,15 @@ config PROC_PAGE_MONITOR
           /proc/pid/smaps, /proc/pid/clear_refs, /proc/pid/pagemap,
           /proc/kpagecount, and /proc/kpageflags. Disabling these
           interfaces will reduce the size of the kernel by approximately 4kb.
+
+config REPORT_PRESENT_CPUS
+        default n
+        depends on PROC_FS && SMP
+        bool "Report present cpus instead of online cpus"
+        help
+          This is a work around to report Present CPUs instead of Online CPUs.
+          Some power savings implements use CPU hotplug for power domains.
+          It is a bug to enable this on a server or other architecture that
+          uses cpu hotplug in the correct way.
+
+
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 9b45ee84fbc..3a1dafd228d 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -172,7 +172,7 @@ static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
                 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
         tpid = 0;
         if (pid_alive(p)) {
-                struct task_struct *tracer = tracehook_tracer_task(p);
+                struct task_struct *tracer = ptrace_parent(p);
                 if (tracer)
                         tpid = task_pid_nr_ns(tracer, ns);
         }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index fc5bc276769..fc03d161a1d 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -133,6 +133,12 @@ struct pid_entry {
                 NULL, &proc_single_file_operations,     \
                 { .proc_show = show } )
 
+/* ANDROID is for special files in /proc. */
+#define ANDROID(NAME, MODE, OTYPE)                      \
+        NOD(NAME, (S_IFREG|(MODE)),                     \
+                &proc_##OTYPE##_inode_operations,       \
+                &proc_##OTYPE##_operations, {})
+
 /*
  * Count the number of hardlinks for the pid_entry table, excluding the .
  * and .. links.
@@ -216,7 +222,7 @@ static struct mm_struct *__check_mem_permission(struct task_struct *task)
         if (task_is_stopped_or_traced(task)) {
                 int match;
                 rcu_read_lock();
-                match = (tracehook_tracer_task(task) == current);
+                match = (ptrace_parent(task) == current);
                 rcu_read_unlock();
                 if (match && ptrace_may_access(task, PTRACE_MODE_ATTACH))
                         return mm;
@@ -263,7 +269,8 @@ struct mm_struct *mm_for_maps(struct task_struct *task)
 
         mm = get_task_mm(task);
         if (mm && mm != current->mm &&
-                        !ptrace_may_access(task, PTRACE_MODE_READ)) {
+                        !ptrace_may_access(task, PTRACE_MODE_READ) &&
+                        !capable(CAP_SYS_RESOURCE)) {
                 mmput(mm);
                 mm = ERR_PTR(-EACCES);
         }
@@ -673,7 +680,7 @@ static int mounts_open_common(struct inode *inode, struct file *file,
         p->m.private = p;
         p->ns = ns;
         p->root = root;
-        p->event = ns->event;
+        p->m.poll_event = ns->event;
 
         return 0;
 
@@ -884,6 +891,10 @@ out_no_task:
         return ret;
 }
 
+#define mem_write NULL
+
+#ifndef mem_write
+/* This is a security hazard */
 static ssize_t mem_write(struct file * file, const char __user *buf,
                          size_t count, loff_t *ppos)
 {
@@ -942,6 +953,7 @@ out_task:
 out_no_task:
         return copied;
 }
+#endif
 
 loff_t mem_lseek(struct file *file, loff_t offset, int orig)
 {
@@ -1118,10 +1130,9 @@ static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
          * Warn that /proc/pid/oom_adj is deprecated, see
          * Documentation/feature-removal-schedule.txt.
          */
-        printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, "
-                        "please use /proc/%d/oom_score_adj instead.\n",
-                        current->comm, task_pid_nr(current),
-                        task_pid_nr(task), task_pid_nr(task));
+        printk_once(KERN_WARNING "%s (%d): /proc/%d/oom_adj is deprecated, please use /proc/%d/oom_score_adj instead.\n",
+                  current->comm, task_pid_nr(current), task_pid_nr(task),
+                  task_pid_nr(task));
         task->signal->oom_adj = oom_adjust;
         /*
          * Scale /proc/pid/oom_score_adj appropriately ensuring that a maximum
@@ -1141,6 +1152,38 @@ out:
         return err < 0 ? err : count;
 }
 
+static int oom_adjust_permission(struct inode *inode, int mask)
+{
+        uid_t uid;
+        struct task_struct *p;
+
+        if (mask & MAY_NOT_BLOCK)
+                return -ECHILD;
+
+        p = get_proc_task(inode);
+        if(p) {
+                uid = task_uid(p);
+                put_task_struct(p);
+        }
+
+        /*
+         * System Server (uid == 1000) is granted access to oom_adj of all 
+         * android applications (uid > 10000) as and services (uid >= 1000)
+         */
+        if (p && (current_fsuid() == 1000) && (uid >= 1000)) {
+                if (inode->i_mode >> 6 & mask) {
+                        return 0;
+                }
+        }
+
+        /* Fall back to default. */
+        return generic_permission(inode, mask);
+}
+
+static const struct inode_operations proc_oom_adjust_inode_operations = {
+        .permission     = oom_adjust_permission,
+};
+
 static const struct file_operations proc_oom_adjust_operations = {
         .read           = oom_adjust_read,
         .write          = oom_adjust_write,
@@ -1920,6 +1963,14 @@ static int proc_fd_info(struct inode *inode, struct path *path, char *info)
                 spin_lock(&files->file_lock);
                 file = fcheck_files(files, fd);
                 if (file) {
+                        unsigned int f_flags;
+                        struct fdtable *fdt;
+
+                        fdt = files_fdtable(files);
+                        f_flags = file->f_flags & ~O_CLOEXEC;
+                        if (FD_ISSET(fd, fdt->close_on_exec))
+                                f_flags |= O_CLOEXEC;
+
                         if (path) {
                                 *path = file->f_path;
                                 path_get(&file->f_path);
@@ -1929,7 +1980,7 @@ static int proc_fd_info(struct inode *inode, struct path *path, char *info)
                                          "pos:\t%lli\n"
                                          "flags:\t0%o\n",
                                          (long long) file->f_pos,
-                                         file->f_flags);
+                                         f_flags);
                         spin_unlock(&files->file_lock);
                         put_files_struct(files);
                         return 0;
@@ -2167,9 +2218,9 @@ static const struct file_operations proc_fd_operations = {
  * /proc/pid/fd needs a special permission handler so that a process can still
  * access /proc/self/fd after it has executed a setuid().
  */
-static int proc_fd_permission(struct inode *inode, int mask, unsigned int flags)
+static int proc_fd_permission(struct inode *inode, int mask)
 {
-        int rv = generic_permission(inode, mask, flags, NULL);
+        int rv = generic_permission(inode, mask);
         if (rv == 0)
                 return 0;
         if (task_pid(current) == proc_pid(inode))
@@ -2707,9 +2758,16 @@ static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
 {
         struct task_io_accounting acct = task->ioac;
         unsigned long flags;
+        int result;
+
+        result = mutex_lock_killable(&task->signal->cred_guard_mutex);
+        if (result)
+                return result;
 
-        if (!ptrace_may_access(task, PTRACE_MODE_READ))
-                return -EACCES;
+        if (!ptrace_may_access(task, PTRACE_MODE_READ)) {
+                result = -EACCES;
+                goto out_unlock;
+        }
 
         if (whole && lock_task_sighand(task, &flags)) {
                 struct task_struct *t = task;
@@ -2720,7 +2778,7 @@ static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
 
                 unlock_task_sighand(task, &flags);
         }
-        return sprintf(buffer,
+        result = sprintf(buffer,
                         "rchar: %llu\n"
                         "wchar: %llu\n"
                         "syscr: %llu\n"
@@ -2735,6 +2793,9 @@ static int do_io_accounting(struct task_struct *task, char *buffer, int whole)
                         (unsigned long long)acct.read_bytes,
                         (unsigned long long)acct.write_bytes,
                         (unsigned long long)acct.cancelled_write_bytes);
+out_unlock:
+        mutex_unlock(&task->signal->cred_guard_mutex);
+        return result;
 }
 
 static int proc_tid_io_accounting(struct task_struct *task, char *buffer)
@@ -2829,7 +2890,7 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("cgroup",  S_IRUGO, proc_cgroup_operations),
 #endif
         INF("oom_score",  S_IRUGO, proc_oom_score),
-        REG("oom_adj",    S_IRUGO|S_IWUSR, proc_oom_adjust_operations),
+        ANDROID("oom_adj",S_IRUGO|S_IWUSR, oom_adjust),
         REG("oom_score_adj", S_IRUGO|S_IWUSR, proc_oom_score_adj_operations),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, proc_loginuid_operations),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index f1637f17c37..9d99131d0d6 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -620,8 +620,7 @@ static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
         if (!ent) goto out;
 
         memset(ent, 0, sizeof(struct proc_dir_entry));
-        memcpy(((char *) ent) + sizeof(struct proc_dir_entry), fn, len + 1);
-        ent->name = ((char *) ent) + sizeof(*ent);
+        memcpy(ent->name, fn, len + 1);
         ent->namelen = len;
         ent->mode = mode;
         ent->nlink = nlink;
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 74b48cfa1bb..7ed72d6c1c6 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -319,7 +319,7 @@ static int proc_reg_open(struct inode *inode, struct file *file)
         if (!pde->proc_fops) {
                 spin_unlock(&pde->pde_unload_lock);
                 kfree(pdeo);
-                return -EINVAL;
+                return -ENOENT;
         }
         pde->pde_users++;
         open = pde->proc_fops->open;
diff --git a/fs/proc/meminfo.c b/fs/proc/meminfo.c
index ed257d14156..80e4645f799 100644
--- a/fs/proc/meminfo.c
+++ b/fs/proc/meminfo.c
@@ -10,7 +10,7 @@
 #include <linux/seq_file.h>
 #include <linux/swap.h>
 #include <linux/vmstat.h>
-#include <asm/atomic.h>
+#include <linux/atomic.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include "internal.h"
@@ -131,12 +131,13 @@ static int meminfo_proc_show(struct seq_file *m, void *v)
                 K(i.freeswap),
                 K(global_page_state(NR_FILE_DIRTY)),
                 K(global_page_state(NR_WRITEBACK)),
-                K(global_page_state(NR_ANON_PAGES)
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
+                K(global_page_state(NR_ANON_PAGES)
                   + global_page_state(NR_ANON_TRANSPARENT_HUGEPAGES) *
-                  HPAGE_PMD_NR
+                  HPAGE_PMD_NR),
+#else
+                K(global_page_state(NR_ANON_PAGES)),
 #endif
-                  ),
                 K(global_page_state(NR_FILE_MAPPED)),
                 K(global_page_state(NR_SHMEM)),
                 K(global_page_state(NR_SLAB_RECLAIMABLE) +
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 9020ac15baa..f738024ccc8 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -197,15 +197,15 @@ static __net_init int proc_net_ns_init(struct net *net)
         int err;
 
         err = -ENOMEM;
-        netd = kzalloc(sizeof(*netd), GFP_KERNEL);
+        netd = kzalloc(sizeof(*netd) + 4, GFP_KERNEL);
         if (!netd)
                 goto out;
 
         netd->data = net;
         netd->nlink = 2;
-        netd->name = "net";
         netd->namelen = 3;
         netd->parent = &proc_root;
+        memcpy(netd->name, "net", 4);
 
         err = -EEXIST;
         net_statd = proc_net_mkdir(net, "stat", netd);
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index d167de365a8..1a77dbef226 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -294,7 +294,7 @@ out:
         return ret;
 }
 
-static int proc_sys_permission(struct inode *inode, int mask,unsigned int flags)
+static int proc_sys_permission(struct inode *inode, int mask)
 {
         /*
          * sysctl entries that are not writeable,
@@ -316,7 +316,7 @@ static int proc_sys_permission(struct inode *inode, int mask,unsigned int flags)
         if (!table) /* global root - r-xr-xr-x */
                 error = mask & MAY_WRITE ? -EACCES : 0;
         else /* Use the permissions on the sysctl table entry */
-                error = sysctl_perm(head->root, table, mask);
+                error = sysctl_perm(head->root, table, mask & ~MAY_NOT_BLOCK);
 
         sysctl_head_finish(head);
         return error;
diff --git a/fs/proc/root.c b/fs/proc/root.c
index d6c3b416529..9a8a2b77b87 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -186,13 +186,13 @@ static const struct inode_operations proc_root_inode_operations = {
 struct proc_dir_entry proc_root = {
         .low_ino        = PROC_ROOT_INO, 
         .namelen        = 5, 
-        .name           = "/proc",
         .mode           = S_IFDIR | S_IRUGO | S_IXUGO, 
         .nlink          = 2, 
         .count          = ATOMIC_INIT(1),
         .proc_iops      = &proc_root_inode_operations, 
         .proc_fops      = &proc_root_operations,
         .parent         = &proc_root,
+        .name           = "/proc",
 };
 
 int pid_ns_prepare_proc(struct pid_namespace *ns)
diff --git a/fs/proc/stat.c b/fs/proc/stat.c
index 9758b654a1b..4b758ad5c83 100644
--- a/fs/proc/stat.c
+++ b/fs/proc/stat.c
@@ -75,7 +75,11 @@ static int show_stat(struct seq_file *p, void *v)
                 (unsigned long long)cputime64_to_clock_t(steal),
                 (unsigned long long)cputime64_to_clock_t(guest),
                 (unsigned long long)cputime64_to_clock_t(guest_nice));
+#if defined(CONFIG_REPORT_PRESENT_CPUS)
+        for_each_present_cpu(i) {
+#else
         for_each_online_cpu(i) {
+#endif
 
                 /* Copy values here to work around gcc-2.95.3, gcc-2.96 */
                 user = kstat_cpu(i).cpustat.user;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 25b6a887adb..c7d4ee663f1 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -877,30 +877,54 @@ struct numa_maps_private {
         struct numa_maps md;
 };
 
-static void gather_stats(struct page *page, struct numa_maps *md, int pte_dirty)
+static void gather_stats(struct page *page, struct numa_maps *md, int pte_dirty,
+                        unsigned long nr_pages)
 {
         int count = page_mapcount(page);
 
-        md->pages++;
+        md->pages += nr_pages;
         if (pte_dirty || PageDirty(page))
-                md->dirty++;
+                md->dirty += nr_pages;
 
         if (PageSwapCache(page))
-                md->swapcache++;
+                md->swapcache += nr_pages;
 
         if (PageActive(page) || PageUnevictable(page))
-                md->active++;
+                md->active += nr_pages;
 
         if (PageWriteback(page))
-                md->writeback++;
+                md->writeback += nr_pages;
 
         if (PageAnon(page))
-                md->anon++;
+                md->anon += nr_pages;
 
         if (count > md->mapcount_max)
                 md->mapcount_max = count;
 
-        md->node[page_to_nid(page)]++;
+        md->node[page_to_nid(page)] += nr_pages;
+}
+
+static struct page *can_gather_numa_stats(pte_t pte, struct vm_area_struct *vma,
+                unsigned long addr)
+{
+        struct page *page;
+        int nid;
+
+        if (!pte_present(pte))
+                return NULL;
+
+        page = vm_normal_page(vma, addr, pte);
+        if (!page)
+                return NULL;
+
+        if (PageReserved(page))
+                return NULL;
+
+        nid = page_to_nid(page);
+        if (!node_isset(nid, node_states[N_HIGH_MEMORY]))
+                return NULL;
+
+        return page;
 }
 
 static int gather_pte_stats(pmd_t *pmd, unsigned long addr,
@@ -912,26 +936,32 @@ static int gather_pte_stats(pmd_t *pmd, unsigned long addr,
         pte_t *pte;
 
         md = walk->private;
-        orig_pte = pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
-        do {
-                struct page *page;
-                int nid;
+        spin_lock(&walk->mm->page_table_lock);
+        if (pmd_trans_huge(*pmd)) {
+                if (pmd_trans_splitting(*pmd)) {
+                        spin_unlock(&walk->mm->page_table_lock);
+                        wait_split_huge_page(md->vma->anon_vma, pmd);
+                } else {
+                        pte_t huge_pte = *(pte_t *)pmd;
+                        struct page *page;
 
-                if (!pte_present(*pte))
-                        continue;
+                        page = can_gather_numa_stats(huge_pte, md->vma, addr);
+                        if (page)
+                                gather_stats(page, md, pte_dirty(huge_pte),
+                                                HPAGE_PMD_SIZE/PAGE_SIZE);
+                        spin_unlock(&walk->mm->page_table_lock);
+                        return 0;
+                }
+        } else {
+                spin_unlock(&walk->mm->page_table_lock);
+        }
 
-                page = vm_normal_page(md->vma, addr, *pte);
+        orig_pte = pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
+        do {
+                struct page *page = can_gather_numa_stats(*pte, md->vma, addr);
                 if (!page)
                         continue;
-
-                if (PageReserved(page))
-                        continue;
-
-                nid = page_to_nid(page);
-                if (!node_isset(nid, node_states[N_HIGH_MEMORY]))
-                        continue;
-
-                gather_stats(page, md, pte_dirty(*pte));
+                gather_stats(page, md, pte_dirty(*pte), 1);
 
         } while (pte++, addr += PAGE_SIZE, addr != end);
         pte_unmap_unlock(orig_pte, ptl);
@@ -952,7 +982,7 @@ static int gather_hugetbl_stats(pte_t *pte, unsigned long hmask,
                 return 0;
 
         md = walk->private;
-        gather_stats(page, md, pte_dirty(*pte));
+        gather_stats(page, md, pte_dirty(*pte), 1);
         return 0;
 }
 
@@ -1009,6 +1039,9 @@ static int show_numa_map(struct seq_file *m, void *v)
                 seq_printf(m, " stack");
         }
 
+        if (is_vm_hugetlb_page(vma))
+                seq_printf(m, " huge");
+
         walk_page_range(vma->vm_start, vma->vm_end, &walk);
 
         if (!md->pages)