1 files changed, 118 insertions, 42 deletions

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 701b8cbceb05..1c876e27ff93 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -73,6 +73,7 @@ struct sched_param {
 #include <linux/seccomp.h>
 #include <linux/rcupdate.h>
 #include <linux/futex.h>
+#include <linux/rtmutex.h>
 
 #include <linux/time.h>
 #include <linux/param.h>
@@ -83,6 +84,7 @@ struct sched_param {
 #include <asm/processor.h>
 
 struct exec_domain;
+struct futex_pi_state;
 
 /*
  * List of flags we want to share for kernel threads,
@@ -123,6 +125,7 @@ extern unsigned long nr_running(void);
 extern unsigned long nr_uninterruptible(void);
 extern unsigned long nr_active(void);
 extern unsigned long nr_iowait(void);
+extern unsigned long weighted_cpuload(const int cpu);
 
 
 /*
@@ -181,11 +184,11 @@ extern unsigned long nr_iowait(void);
 extern rwlock_t tasklist_lock;
 extern spinlock_t mmlist_lock;
 
-typedef struct task_struct task_t;
+struct task_struct;
 
 extern void sched_init(void);
 extern void sched_init_smp(void);
-extern void init_idle(task_t *idle, int cpu);
+extern void init_idle(struct task_struct *idle, int cpu);
 
 extern cpumask_t nohz_cpu_mask;
 
@@ -358,6 +361,14 @@ struct sighand_struct {
         spinlock_t              siglock;
 };
 
+struct pacct_struct {
+        int                     ac_flag;
+        long                    ac_exitcode;
+        unsigned long           ac_mem;
+        cputime_t               ac_utime, ac_stime;
+        unsigned long           ac_minflt, ac_majflt;
+};
+
 /*
  * NOTE! "signal_struct" does not have it's own
  * locking, because a shared signal_struct always
@@ -372,7 +383,7 @@ struct signal_struct {
         wait_queue_head_t       wait_chldexit;  /* for wait4() */
 
         /* current thread group signal load-balancing target: */
-        task_t                  *curr_target;
+        struct task_struct      *curr_target;
 
         /* shared signal handling: */
         struct sigpending       shared_pending;
@@ -449,6 +460,9 @@ struct signal_struct {
         struct key *session_keyring;    /* keyring inherited over fork */
         struct key *process_keyring;    /* keyring private to this process */
 #endif
+#ifdef CONFIG_BSD_PROCESS_ACCT
+        struct pacct_struct pacct;      /* per-process accounting information */
+#endif
 };
 
 /* Context switch must be unlocked if interrupts are to be enabled */
@@ -483,8 +497,11 @@ struct signal_struct {
 
 #define MAX_PRIO                (MAX_RT_PRIO + 40)
 
-#define rt_task(p)              (unlikely((p)->prio < MAX_RT_PRIO))
+#define rt_prio(prio)           unlikely((prio) < MAX_RT_PRIO)
+#define rt_task(p)              rt_prio((p)->prio)
 #define batch_task(p)           (unlikely((p)->policy == SCHED_BATCH))
+#define has_rt_policy(p) \
+        unlikely((p)->policy != SCHED_NORMAL && (p)->policy != SCHED_BATCH)
 
 /*
  * Some day this will be a full-fledged user tracking system..
@@ -494,7 +511,7 @@ struct user_struct {
         atomic_t processes;     /* How many processes does this user have? */
         atomic_t files;         /* How many open files does this user have? */
         atomic_t sigpending;    /* How many pending signals does this user have? */
-#ifdef CONFIG_INOTIFY
+#ifdef CONFIG_INOTIFY_USER
         atomic_t inotify_watches; /* How many inotify watches does this user have? */
         atomic_t inotify_devs;  /* How many inotify devs does this user have opened? */
 #endif
@@ -517,7 +534,6 @@ extern struct user_struct *find_user(uid_t);
 extern struct user_struct root_user;
 #define INIT_USER (&root_user)
 
-typedef struct prio_array prio_array_t;
 struct backing_dev_info;
 struct reclaim_state;
 
@@ -547,9 +563,9 @@ enum idle_type
 /*
  * sched-domains (multiprocessor balancing) declarations:
  */
-#ifdef CONFIG_SMP
 #define SCHED_LOAD_SCALE        128UL   /* increase resolution of load */
 
+#ifdef CONFIG_SMP
 #define SD_LOAD_BALANCE         1       /* Do load balancing on this domain. */
 #define SD_BALANCE_NEWIDLE      2       /* Balance when about to become idle */
 #define SD_BALANCE_EXEC         4       /* Balance on exec */
@@ -558,6 +574,11 @@ enum idle_type
 #define SD_WAKE_AFFINE          32      /* Wake task to waking CPU */
 #define SD_WAKE_BALANCE         64      /* Perform balancing at task wakeup */
 #define SD_SHARE_CPUPOWER       128     /* Domain members share cpu power */
+#define SD_POWERSAVINGS_BALANCE 256     /* Balance for power savings */
+
+#define BALANCE_FOR_POWER       ((sched_mc_power_savings || sched_smt_power_savings) \
+                                 ? SD_POWERSAVINGS_BALANCE : 0)
+
 
 struct sched_group {
         struct sched_group *next;       /* Must be a circular list */
@@ -627,7 +648,7 @@ struct sched_domain {
 #endif
 };
 
-extern void partition_sched_domains(cpumask_t *partition1,
+extern int partition_sched_domains(cpumask_t *partition1,
                                     cpumask_t *partition2);
 
 /*
@@ -677,7 +698,7 @@ extern int groups_search(struct group_info *group_info, gid_t grp);
     ((gi)->blocks[(i)/NGROUPS_PER_BLOCK][(i)%NGROUPS_PER_BLOCK])
 
 #ifdef ARCH_HAS_PREFETCH_SWITCH_STACK
-extern void prefetch_stack(struct task_struct*);
+extern void prefetch_stack(struct task_struct *t);
 #else
 static inline void prefetch_stack(struct task_struct *t) { }
 #endif
@@ -693,6 +714,8 @@ enum sleep_type {
         SLEEP_INTERRUPTED,
 };
 
+struct prio_array;
+
 struct task_struct {
         volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
         struct thread_info *thread_info;
@@ -702,12 +725,15 @@ struct task_struct {
 
         int lock_depth;         /* BKL lock depth */
 
-#if defined(CONFIG_SMP) && defined(__ARCH_WANT_UNLOCKED_CTXSW)
+#ifdef CONFIG_SMP
+#ifdef __ARCH_WANT_UNLOCKED_CTXSW
         int oncpu;
 #endif
-        int prio, static_prio;
+#endif
+        int load_weight;        /* for niceness load balancing purposes */
+        int prio, static_prio, normal_prio;
         struct list_head run_list;
-        prio_array_t *array;
+        struct prio_array *array;
 
         unsigned short ioprio;
         unsigned int btrace_seq;
@@ -831,13 +857,43 @@ struct task_struct {
         u32 self_exec_id;
 /* Protection of (de-)allocation: mm, files, fs, tty, keyrings */
         spinlock_t alloc_lock;
-/* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
-        spinlock_t proc_lock;
+
+        /* Protection of the PI data structures: */
+        spinlock_t pi_lock;
+
+#ifdef CONFIG_RT_MUTEXES
+        /* PI waiters blocked on a rt_mutex held by this task */
+        struct plist_head pi_waiters;
+        /* Deadlock detection and priority inheritance handling */
+        struct rt_mutex_waiter *pi_blocked_on;
+#endif
 
 #ifdef CONFIG_DEBUG_MUTEXES
         /* mutex deadlock detection */
         struct mutex_waiter *blocked_on;
 #endif
+#ifdef CONFIG_TRACE_IRQFLAGS
+        unsigned int irq_events;
+        int hardirqs_enabled;
+        unsigned long hardirq_enable_ip;
+        unsigned int hardirq_enable_event;
+        unsigned long hardirq_disable_ip;
+        unsigned int hardirq_disable_event;
+        int softirqs_enabled;
+        unsigned long softirq_disable_ip;
+        unsigned int softirq_disable_event;
+        unsigned long softirq_enable_ip;
+        unsigned int softirq_enable_event;
+        int hardirq_context;
+        int softirq_context;
+#endif
+#ifdef CONFIG_LOCKDEP
+# define MAX_LOCK_DEPTH 30UL
+        u64 curr_chain_key;
+        int lockdep_depth;
+        struct held_lock held_locks[MAX_LOCK_DEPTH];
+        unsigned int lockdep_recursion;
+#endif
 
 /* journalling filesystem info */
         void *journal_info;
@@ -845,7 +901,6 @@ struct task_struct {
 /* VM state */
         struct reclaim_state *reclaim_state;
 
-        struct dentry *proc_dentry;
         struct backing_dev_info *backing_dev_info;
 
         struct io_context *io_context;
@@ -880,6 +935,8 @@ struct task_struct {
 #ifdef CONFIG_COMPAT
         struct compat_robust_list_head __user *compat_robust_list;
 #endif
+        struct list_head pi_state_list;
+        struct futex_pi_state *pi_state_cache;
 
         atomic_t fs_excl;       /* holding fs exclusive resources */
         struct rcu_head rcu;
@@ -941,13 +998,13 @@ static inline void put_task_struct(struct task_struct *t)
 #define PF_KSWAPD       0x00040000      /* I am kswapd */
 #define PF_SWAPOFF      0x00080000      /* I am in swapoff */
 #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
-#define PF_SYNCWRITE    0x00200000      /* I am doing a sync write */
-#define PF_BORROWED_MM  0x00400000      /* I am a kthread doing use_mm */
-#define PF_RANDOMIZE    0x00800000      /* randomize virtual address space */
-#define PF_SWAPWRITE    0x01000000      /* Allowed to write to swap */
-#define PF_SPREAD_PAGE  0x04000000      /* Spread page cache over cpuset */
-#define PF_SPREAD_SLAB  0x08000000      /* Spread some slab caches over cpuset */
+#define PF_BORROWED_MM  0x00200000      /* I am a kthread doing use_mm */
+#define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
+#define PF_SWAPWRITE    0x00800000      /* Allowed to write to swap */
+#define PF_SPREAD_PAGE  0x01000000      /* Spread page cache over cpuset */
+#define PF_SPREAD_SLAB  0x02000000      /* Spread some slab caches over cpuset */
 #define PF_MEMPOLICY    0x10000000      /* Non-default NUMA mempolicy */
+#define PF_MUTEX_TESTER 0x20000000      /* Thread belongs to the rt mutex tester */
 
 /*
  * Only the _current_ task can read/write to tsk->flags, but other
@@ -975,9 +1032,9 @@ static inline void put_task_struct(struct task_struct *t)
 #define used_math() tsk_used_math(current)
 
 #ifdef CONFIG_SMP
-extern int set_cpus_allowed(task_t *p, cpumask_t new_mask);
+extern int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask);
 #else
-static inline int set_cpus_allowed(task_t *p, cpumask_t new_mask)
+static inline int set_cpus_allowed(struct task_struct *p, cpumask_t new_mask)
 {
         if (!cpu_isset(0, new_mask))
                 return -EINVAL;
@@ -986,7 +1043,8 @@ static inline int set_cpus_allowed(task_t *p, cpumask_t new_mask)
 #endif
 
 extern unsigned long long sched_clock(void);
-extern unsigned long long current_sched_time(const task_t *current_task);
+extern unsigned long long
+current_sched_time(const struct task_struct *current_task);
 
 /* sched_exec is called by processes performing an exec */
 #ifdef CONFIG_SMP
@@ -1002,16 +1060,29 @@ static inline void idle_task_exit(void) {}
 #endif
 
 extern void sched_idle_next(void);
-extern void set_user_nice(task_t *p, long nice);
-extern int task_prio(const task_t *p);
-extern int task_nice(const task_t *p);
-extern int can_nice(const task_t *p, const int nice);
-extern int task_curr(const task_t *p);
+
+#ifdef CONFIG_RT_MUTEXES
+extern int rt_mutex_getprio(struct task_struct *p);
+extern void rt_mutex_setprio(struct task_struct *p, int prio);
+extern void rt_mutex_adjust_pi(struct task_struct *p);
+#else
+static inline int rt_mutex_getprio(struct task_struct *p)
+{
+        return p->normal_prio;
+}
+# define rt_mutex_adjust_pi(p)          do { } while (0)
+#endif
+
+extern void set_user_nice(struct task_struct *p, long nice);
+extern int task_prio(const struct task_struct *p);
+extern int task_nice(const struct task_struct *p);
+extern int can_nice(const struct task_struct *p, const int nice);
+extern int task_curr(const struct task_struct *p);
 extern int idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int, struct sched_param *);
-extern task_t *idle_task(int cpu);
-extern task_t *curr_task(int cpu);
-extern void set_curr_task(int cpu, task_t *p);
+extern struct task_struct *idle_task(int cpu);
+extern struct task_struct *curr_task(int cpu);
+extern void set_curr_task(int cpu, struct task_struct *p);
 
 void yield(void);
 
@@ -1068,8 +1139,8 @@ extern void FASTCALL(wake_up_new_task(struct task_struct * tsk,
 #else
  static inline void kick_process(struct task_struct *tsk) { }
 #endif
-extern void FASTCALL(sched_fork(task_t * p, int clone_flags));
-extern void FASTCALL(sched_exit(task_t * p));
+extern void FASTCALL(sched_fork(struct task_struct * p, int clone_flags));
+extern void FASTCALL(sched_exit(struct task_struct * p));
 
 extern int in_group_p(gid_t);
 extern int in_egroup_p(gid_t);
@@ -1102,7 +1173,7 @@ extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int __kill_pg_info(int sig, struct siginfo *info, pid_t pgrp);
 extern int kill_pg_info(int, struct siginfo *, pid_t);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
-extern int kill_proc_info_as_uid(int, struct siginfo *, pid_t, uid_t, uid_t);
+extern int kill_proc_info_as_uid(int, struct siginfo *, pid_t, uid_t, uid_t, u32);
 extern void do_notify_parent(struct task_struct *, int);
 extern void force_sig(int, struct task_struct *);
 extern void force_sig_specific(int, struct task_struct *);
@@ -1174,17 +1245,17 @@ extern NORET_TYPE void do_group_exit(int);
 extern void daemonize(const char *, ...);
 extern int allow_signal(int);
 extern int disallow_signal(int);
-extern task_t *child_reaper;
+extern struct task_struct *child_reaper;
 
 extern int do_execve(char *, char __user * __user *, char __user * __user *, struct pt_regs *);
 extern long do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long, int __user *, int __user *);
-task_t *fork_idle(int);
+struct task_struct *fork_idle(int);
 
 extern void set_task_comm(struct task_struct *tsk, char *from);
 extern void get_task_comm(char *to, struct task_struct *tsk);
 
 #ifdef CONFIG_SMP
-extern void wait_task_inactive(task_t * p);
+extern void wait_task_inactive(struct task_struct * p);
 #else
 #define wait_task_inactive(p)   do { } while (0)
 #endif
@@ -1210,13 +1281,13 @@ extern void wait_task_inactive(task_t * p);
 /* de_thread depends on thread_group_leader not being a pid based check */
 #define thread_group_leader(p)  (p == p->group_leader)
 
-static inline task_t *next_thread(const task_t *p)
+static inline struct task_struct *next_thread(const struct task_struct *p)
 {
         return list_entry(rcu_dereference(p->thread_group.next),
-                                task_t, thread_group);
+                          struct task_struct, thread_group);
 }
 
-static inline int thread_group_empty(task_t *p)
+static inline int thread_group_empty(struct task_struct *p)
 {
         return list_empty(&p->thread_group);
 }
@@ -1225,7 +1296,7 @@ static inline int thread_group_empty(task_t *p)
                 (thread_group_leader(p) && !thread_group_empty(p))
 
 /*
- * Protects ->fs, ->files, ->mm, ->ptrace, ->group_info, ->comm, keyring
+ * Protects ->fs, ->files, ->mm, ->group_info, ->comm, keyring
  * subscriptions and synchronises with wait4().  Also used in procfs.  Also
  * pins the final release of task.io_context.  Also protects ->cpuset.
  *
@@ -1401,6 +1472,11 @@ static inline void arch_pick_mmap_layout(struct mm_struct *mm)
 extern long sched_setaffinity(pid_t pid, cpumask_t new_mask);
 extern long sched_getaffinity(pid_t pid, cpumask_t *mask);
 
+#include <linux/sysdev.h>
+extern int sched_mc_power_savings, sched_smt_power_savings;
+extern struct sysdev_attribute attr_sched_mc_power_savings, attr_sched_smt_power_savings;
+extern int sched_create_sysfs_power_savings_entries(struct sysdev_class *cls);
+
 extern void normalize_rt_tasks(void);
 
 #ifdef CONFIG_PM