I've been hacking quite a bit on the pidspace code. I've run
into a bug or two, and had a heck of a time debugging it.
Other than my inferior puny monkey brain, I'm directing some
of the blame squarely in the direction of the 'struct pid'.
We have pid_t, pid_ns, struct pid and pid_link, at _least_.
Seeing code like get_pid(pid->pid_ns->pid_type[PIDTYPE_PID])
is mind-numbing to say the least. It makes it really hard
to comprehend, and even harder to debug.
We honestly have a lot of code like this:
pid = pid_nr(filp->f_owner.pid);
WTF? It's getting a pid from a pid? Huh? :)
It makes sense when you go look at the structures, but
sitting in the middle of a function and when you can't see
all of the struct declarations can be really sketchy.
So, I propose that we rename the one structure that seems to
be the focus of the problem: 'struct pid'. Fundamentally, it
is a 'process identifier': it helps the kernel to identifty
processes. However, as I noted, 'pid' is a wee bit overloaded.
In addition to "identifying" processes, this structure acts
as an indirection or handle to them. So, I propse we call
these things 'struct task_ref'. Just reading some of the
code that I've modified in here makes me feel like this is
the right way.
Compare the two sentences below:
Oh, I have a task_ref? What kind is it? Oh, it's a pgid
reference because I have REFTYPE_PGID.
Oh, I have a pid? What kind is it? Oh, it's a pid because
I have PIDTYPE_PID.
Which makes more sense?
So, this still needs some work converting some of the
function names, but it compiles as-is. Any ideas for better
names?
Signed-off-by: Dave Hansen <hansendc@us.ibm.com>
---
lxc-dave/drivers/char/keyboard.c | 10 +-
lxc-dave/drivers/char/n_r3964.c | 32 +++---
lxc-dave/drivers/char/tty_io.c | 66 ++++++-------
lxc-dave/drivers/char/vt.c | 2
lxc-dave/drivers/char/vt_ioctl.c | 16 +--
lxc-dave/drivers/net/tun.c | 2
lxc-dave/drivers/s390/char/fs3270.c | 4
lxc-dave/drivers/usb/core/devio.c | 12 +-
lxc-dave/drivers/usb/core/inode.c | 2
lxc-dave/drivers/usb/core/usb.h | 2
lxc-dave/files | 42 --------
lxc-dave/fs/autofs/autofs_i.h | 2
lxc-dave/fs/autofs/inode.c | 4
lxc-dave/fs/autofs/root.c | 2
lxc-dave/fs/compat.c | 4
lxc-dave/fs/dnotify.c | 2
lxc-dave/fs/exec.c | 8 -
lxc-dave/fs/fcntl.c | 63 ++++++-------
lxc-dave/fs/file_table.c | 2
lxc-dave/fs/ioprio.c | 17 +--
lxc-dave/fs/locks.c | 2
lxc-dave/fs/ncpfs/inode.c | 20 ++--
lxc-dave/fs/proc/array.c | 2
lxc-dave/fs/proc/base.c | 52 +++++-----
lxc-dave/fs/proc/inode.c | 4
lxc-dave/fs/proc/internal.h | 6 -
lxc-dave/fs/proc/root.c | 4
lxc-dave/fs/proc/task_mmu.c | 4
lxc-dave/fs/proc/task_nommu.c | 5 -
lxc-dave/fs/smbfs/inode.c | 8 -
lxc-dave/fs/smbfs/proc.c | 4
lxc-dave/fs/smbfs/smbiod.c | 10 +-
lxc-dave/include/linux/console_struct.h | 2
lxc-dave/include/linux/fs.h | 8 +
lxc-dave/include/linux/init_task.h | 22 ++--
lxc-dave/include/linux/kernel.h | 4
lxc-dave/include/linux/mmzone.h | 2
lxc-dave/include/linux/n_r3964.h | 2
lxc-dave/include/linux/ncp_mount.h | 2
lxc-dave/include/linux/pid.h | 104 ++++++++++++---------
lxc-dave/include/linux/proc_fs.h | 4
lxc-dave/include/linux/sched.h | 42 ++++----
lxc-dave/include/linux/smb_fs_sb.h | 2
lxc-dave/include/linux/tty.h | 4
lxc-dave/include/linux/vt_kern.h | 2
lxc-dave/init/main.c | 2
lxc-dave/ipc/mqueue.c | 8 -
lxc-dave/kernel/capability.c | 8 -
lxc-dave/kernel/cpuset.c | 10 +-
lxc-dave/kernel/exit.c | 38 ++++----
lxc-dave/kernel/fork.c | 23 ++--
lxc-dave/kernel/futex.c | 2
lxc-dave/kernel/pid.c | 152 ++++++++++++++++----------------
lxc-dave/kernel/rtmutex-debug.c | 1
lxc-dave/kernel/signal.c | 26 ++---
lxc-dave/kernel/sys.c | 28 ++---
lxc-dave/kernel/sysctl.c | 10 +-
lxc-dave/mm/mempolicy.c | 3
lxc-dave/mm/migrate.c | 2
59 files changed, 453 insertions(+), 475 deletions(-)
diff -puN include/linux/pid.h~rename-struct-pid include/linux/pid.h
--- lxc/include/linux/pid.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/pid.h 2007-04-10 16:18:30.000000000 -0700
@@ -3,23 +3,24 @@
#include <linux/rcupdate.h>
-enum pid_type
+enum task_ref_type
{
- PIDTYPE_PID,
- PIDTYPE_PGID,
- PIDTYPE_SID,
- PIDTYPE_MAX
+ REFTYPE_PID,
+ REFTYPE_PGID,
+ REFTYPE_SID,
+ REFTYPE_MAX
};
/*
- * What is struct pid?
+ * What is struct task_ref?
*
- * A struct pid is the kernel's internal notion of a process identifier.
- * It refers to individual tasks, process groups, and sessions. While
- * there are processes attached to it the struct pid lives in a hash
- * table, so it and then the processes that it refers to can be found
- * quickly from the numeric pid value. The attached processes may be
- * quickly accessed by following pointers from struct pid.
+ * A 'struct task_ref' is the kernel's internal notion of a process
+ * identifier. It refers to individual tasks, process groups, and
+ * sessions. While there are processes attached to it the
+ * 'struct task_ref' lives in a hash table, so it and then the
+ * processes that it refers to can be found quickly from the numeric
+ * pid value. The attached processes may be quickly accessed by
+ * following pointers from struct task_ref.
*
* Storing pid_t values in the kernel and refering to them later has a
* problem. The process originally with that pid may have exited and the
@@ -31,89 +32,98 @@ enum pid_type
* the now useless task_struct is still kept. A task_struct plus a
* stack consumes around 10K of low kernel memory. More precisely
* this is THREAD_SIZE + sizeof(struct task_struct). By comparison
- * a struct pid is about 64 bytes.
+ * a struct task_ref is about 64 bytes.
*
- * Holding a reference to struct pid solves both of these problems.
+ * Holding a reference to struct task_ref solves both of these problems.
* It is small so holding a reference does not consume a lot of
- * resources, and since a new struct pid is allocated when the numeric pid
+ * resources, and since a new struct task_ref is allocated when the numeric pid
* value is reused (when pids wrap around) we don't mistakenly refer to new
* processes.
*/
-struct pid
+struct task_ref
{
atomic_t count;
/* Try to keep pid_chain in the same cacheline as nr for find_pid */
- int nr;
+ int pid;
struct hlist_node pid_chain;
- /* lists of tasks that use this pid */
- struct hlist_head tasks[PIDTYPE_MAX];
+ /*
+ * lists of tasks that use this pid.
+ * For instance, ->tasks[REFTYPE_SID]
+ * has all tasks with a session id of
+ * the number in ->pid.
+ */
+ struct hlist_head tasks[REFTYPE_MAX];
struct rcu_head rcu;
};
-extern struct pid init_struct_pid;
+extern struct task_ref init_task_ref;
struct pid_link
{
struct hlist_node node;
- struct pid *pid;
+ struct task_ref *tref;
};
-static inline struct pid *get_pid(struct pid *pid)
+static inline struct task_ref *get_pid(struct task_ref *tref)
{
- if (pid)
- atomic_inc(&pid->count);
- return pid;
+ if (tref)
+ atomic_inc(&tref->count);
+ return tref;
}
-extern void FASTCALL(put_pid(struct pid *pid));
-extern struct task_struct *FASTCALL(pid_task(struct pid *pid, enum pid_type));
-extern struct task_struct *FASTCALL(get_pid_task(struct pid *pid,
- enum pid_type));
+extern void FASTCALL(put_task_ref(struct task_ref *tref));
+extern struct task_struct *FASTCALL(pid_task(struct task_ref *tref,
+ enum task_ref_type));
+extern struct task_struct *FASTCALL(get_pid_task(struct task_ref *tref,
+ enum task_ref_type));
-extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
+extern struct task_ref *get_task_ref(struct task_struct *task,
+ enum task_ref_type type);
/*
* attach_pid() and detach_pid() must be called with the tasklist_lock
* write-held.
*/
-extern int FASTCALL(attach_pid(struct task_struct *task,
- enum pid_type type, struct pid *pid));
-extern void FASTCALL(detach_pid(struct task_struct *task, enum pid_type));
-extern void FASTCALL(transfer_pid(struct task_struct *old,
- struct task_struct *new, enum pid_type));
+extern int FASTCALL(attach_task_ref(struct task_struct *task,
+ enum task_ref_type type,
+ struct task_ref *tref));
+extern void FASTCALL(detach_task_ref(struct task_struct *task, enum task_ref_type));
+extern void FASTCALL(transfer_task_ref(struct task_struct *old,
+ struct task_struct *new,
+ enum task_ref_type));
/*
* look up a PID in the hash table. Must be called with the tasklist_lock
* or rcu_read_lock() held.
*/
-extern struct pid *FASTCALL(find_pid(int nr));
+extern struct task_ref *FASTCALL(find_task(int nr));
/*
* Lookup a PID in the hash table, and return with it's count elevated.
*/
-extern struct pid *find_get_pid(int nr);
-extern struct pid *find_ge_pid(int nr);
+extern struct task_ref *find_get_pid(int nr);
+extern struct task_ref *find_ge_pid(int nr);
-extern struct pid *alloc_pid(void);
-extern void FASTCALL(free_pid(struct pid *pid));
+extern struct task_ref *alloc_task_ref(void);
+extern void FASTCALL(free_task_ref(struct task_ref *tref));
-static inline pid_t pid_nr(struct pid *pid)
+static inline pid_t tref_to_pid(struct task_ref *tref)
{
pid_t nr = 0;
- if (pid)
- nr = pid->nr;
+ if (tref)
+ nr = tref->pid;
return nr;
}
-#define do_each_pid_task(pid, type, task) \
+#define do_each_referenced_task(tref, type, task) \
do { \
struct hlist_node *pos___; \
- if (pid != NULL) \
+ if (tref != NULL) \
hlist_for_each_entry_rcu((task), pos___, \
- &pid->tasks[type], pids[type].node) {
+ &tref->tasks[type], pids[type].node) {
-#define while_each_pid_task(pid, type, task) \
+#define while_each_referenced_task(tref, type, task) \
} \
} while (0)
diff -puN include/linux/console_struct.h~rename-struct-pid include/linux/console_struct.h
--- lxc/include/linux/console_struct.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/console_struct.h 2007-04-10 16:18:30.000000000 -0700
@@ -56,7 +56,7 @@ struct vc_data {
struct tty_struct *vc_tty; /* TTY we are attached to */
/* data for manual vt switching */
struct vt_mode vt_mode;
- struct pid *vt_pid;
+ struct task_ref *vt_tref;
int vt_newvt;
wait_queue_head_t paste_wait;
/* mode flags */
diff -puN include/linux/fs.h~rename-struct-pid include/linux/fs.h
--- lxc/include/linux/fs.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/fs.h 2007-04-10 16:18:30.000000000 -0700
@@ -687,8 +687,9 @@ extern struct block_device *I_BDEV(struc
struct fown_struct {
rwlock_t lock; /* protects pid, uid, euid fields */
- struct pid *pid; /* pid or -pgrp where SIGIO should be sent */
- enum pid_type pid_type; /* Kind of process group SIGIO should be sent to */
+ struct task_ref *tref; /* pid or -pgrp where SIGIO should be sent */
+ enum task_ref_type task_ref_type;
+ /* Kind of process group SIGIO should be sent to */
uid_t uid, euid; /* uid/euid of process setting the owner */
int signum; /* posix.1b rt signal to be delivered on IO */
};
@@ -925,7 +926,8 @@ extern void kill_fasync(struct fasync_st
/* only for net: no internal synchronization */
extern void __kill_fasync(struct fasync_struct *, int, int);
-extern int __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
+extern int __f_setown(struct file *filp, struct task_ref *,
+ enum task_ref_type, int force);
extern int f_setown(struct file *filp, unsigned long arg, int force);
extern void f_delown(struct file *filp);
extern pid_t f_getown(struct file *filp);
diff -puN include/linux/init_task.h~rename-struct-pid include/linux/init_task.h
--- lxc/include/linux/init_task.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/init_task.h 2007-04-10 16:18:30.000000000 -0700
@@ -89,15 +89,15 @@ extern struct nsproxy init_nsproxy;
extern struct group_info init_groups;
-#define INIT_STRUCT_PID { \
+#define INIT_TASK_REF { \
.count = ATOMIC_INIT(1), \
- .nr = 0, \
- /* Don't put this struct pid in pid_hash */ \
+ .pid = 0, \
+ /* Don't put this task_ref in pid_hash */ \
.pid_chain = { .next = NULL, .pprev = NULL }, \
.tasks = { \
- { .first = &init_task.pids[PIDTYPE_PID].node }, \
- { .first = &init_task.pids[PIDTYPE_PGID].node }, \
- { .first = &init_task.pids[PIDTYPE_SID].node }, \
+ { .first = &init_task.pids[REFTYPE_PID].node }, \
+ { .first = &init_task.pids[REFTYPE_PGID].node }, \
+ { .first = &init_task.pids[REFTYPE_SID].node }, \
}, \
.rcu = RCU_HEAD_INIT, \
}
@@ -106,9 +106,9 @@ extern struct group_info init_groups;
{ \
.node = { \
.next = NULL, \
- .pprev = &init_struct_pid.tasks[type].first, \
+ .pprev = &init_task_ref.tasks[type].first, \
}, \
- .pid = &init_struct_pid, \
+ .tref = &init_task_ref, \
}
/*
@@ -162,9 +162,9 @@ extern struct group_info init_groups;
.fs_excl = ATOMIC_INIT(0), \
.pi_lock = SPIN_LOCK_UNLOCKED, \
.pids = { \
- [PIDTYPE_PID] = INIT_PID_LINK(PIDTYPE_PID), \
- [PIDTYPE_PGID] = INIT_PID_LINK(PIDTYPE_PGID), \
- [PIDTYPE_SID] = INIT_PID_LINK(PIDTYPE_SID), \
+ [REFTYPE_PID] = INIT_PID_LINK(REFTYPE_PID), \
+ [REFTYPE_PGID] = INIT_PID_LINK(REFTYPE_PGID), \
+ [REFTYPE_SID] = INIT_PID_LINK(REFTYPE_SID), \
}, \
INIT_TRACE_IRQFLAGS \
INIT_LOCKDEP \
diff -puN include/linux/kernel.h~rename-struct-pid include/linux/kernel.h
--- lxc/include/linux/kernel.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/kernel.h 2007-04-10 16:18:30.000000000 -0700
@@ -135,8 +135,8 @@ extern unsigned long long memparse(char
extern int core_kernel_text(unsigned long addr);
extern int __kernel_text_address(unsigned long addr);
extern int kernel_text_address(unsigned long addr);
-struct pid;
-extern struct pid *session_of_pgrp(struct pid *pgrp);
+struct tref;
+extern struct task_ref *session_of_pgrp(struct task_ref *pgrp);
extern void dump_thread(struct pt_regs *regs, struct user *dump);
diff -puN include/linux/mmzone.h~rename-struct-pid include/linux/mmzone.h
--- lxc/include/linux/mmzone.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/mmzone.h 2007-04-10 16:18:30.000000000 -0700
@@ -619,7 +619,7 @@ int sysctl_min_slab_ratio_sysctl_handler
#ifndef CONFIG_NEED_MULTIPLE_NODES
extern struct pglist_data contig_page_data;
-#define NODE_DATA(nid) (&contig_page_data)
+#define NODE_DATA(nid) ({ (void)nid; &contig_page_data; })
#define NODE_MEM_MAP(nid) mem_map
#define MAX_NODES_SHIFT 1
diff -puN include/linux/ncp_mount.h~rename-struct-pid include/linux/ncp_mount.h
--- lxc/include/linux/ncp_mount.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/ncp_mount.h 2007-04-10 16:18:30.000000000 -0700
@@ -75,7 +75,7 @@ struct ncp_mount_data_kernel {
unsigned int int_flags; /* internal flags */
#define NCP_IMOUNT_LOGGEDIN_POSSIBLE 0x0001
__kernel_uid32_t mounted_uid; /* Who may umount() this filesystem? */
- struct pid *wdog_pid; /* Who cares for our watchdog packets? */
+ struct task_ref *wdog_tref; /* Who cares for our watchdog packets? */
unsigned int ncp_fd; /* The socket to the ncp port */
unsigned int time_out; /* How long should I wait after
sending a NCP request? */
diff -puN include/linux/n_r3964.h~rename-struct-pid include/linux/n_r3964.h
--- lxc/include/linux/n_r3964.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/n_r3964.h 2007-04-10 16:18:30.000000000 -0700
@@ -116,7 +116,7 @@ struct r3964_message;
struct r3964_client_info {
spinlock_t lock;
- struct pid *pid;
+ struct task_ref *tref;
unsigned int sig_flags;
struct r3964_client_info *next;
diff -puN include/linux/proc_fs.h~rename-struct-pid include/linux/proc_fs.h
--- lxc/include/linux/proc_fs.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/proc_fs.h 2007-04-10 16:18:30.000000000 -0700
@@ -265,7 +265,7 @@ union proc_op {
};
struct proc_inode {
- struct pid *pid;
+ struct task_ref *tref;
int fd;
union proc_op op;
struct proc_dir_entry *pde;
@@ -283,7 +283,7 @@ static inline struct proc_dir_entry *PDE
}
struct proc_maps_private {
- struct pid *pid;
+ struct task_ref *tref;
struct task_struct *task;
#ifdef CONFIG_MMU
struct vm_area_struct *tail_vma;
diff -puN include/linux/sched.h~rename-struct-pid include/linux/sched.h
--- lxc/include/linux/sched.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/sched.h 2007-04-10 16:18:30.000000000 -0700
@@ -449,7 +449,7 @@ struct signal_struct {
/* job control IDs */
pid_t pgrp;
- struct pid *tty_old_pgrp;
+ struct task_ref *tty_old_pgrp;
union {
pid_t session __deprecated;
@@ -906,7 +906,7 @@ struct task_struct {
struct task_struct *group_leader; /* threadgroup leader */
/* PID/PID hash table linkage. */
- struct pid_link pids[PIDTYPE_MAX];
+ struct pid_link pids[REFTYPE_MAX];
struct list_head thread_group;
struct completion *vfork_done; /* for vfork() */
@@ -1116,24 +1116,24 @@ static inline void set_signal_session(st
sig->__session = session;
}
-static inline struct pid *task_pid(struct task_struct *task)
+static inline struct task_ref *task_pid(struct task_struct *task)
{
- return task->pids[PIDTYPE_PID].pid;
+ return task->pids[REFTYPE_PID].tref;
}
-static inline struct pid *task_tgid(struct task_struct *task)
+static inline struct task_ref *task_tgid(struct task_struct *task)
{
- return task->group_leader->pids[PIDTYPE_PID].pid;
+ return task->group_leader->pids[REFTYPE_PID].tref;
}
-static inline struct pid *task_pgrp(struct task_struct *task)
+static inline struct task_ref *task_pgrp(struct task_struct *task)
{
- return task->group_leader->pids[PIDTYPE_PGID].pid;
+ return task->group_leader->pids[REFTYPE_PGID].tref;
}
-static inline struct pid *task_session(struct task_struct *task)
+static inline struct task_ref *task_session(struct task_struct *task)
{
- return task->group_leader->pids[PIDTYPE_SID].pid;
+ return task->group_leader->pids[REFTYPE_SID].tref;
}
/**
@@ -1146,7 +1146,7 @@ static inline struct pid *task_session(s
*/
static inline int pid_alive(struct task_struct *p)
{
- return p->pids[PIDTYPE_PID].pid != NULL;
+ return p->pids[REFTYPE_PID].tref != NULL;
}
/**
@@ -1160,7 +1160,7 @@ static inline int is_init(struct task_st
return tsk->pid == 1;
}
-extern struct pid *cad_pid;
+extern struct task_ref *cad_tref;
extern void free_task(struct task_struct *tsk);
#define get_task_struct(tsk) do { atomic_inc(&(tsk)->usage); } while(0)
@@ -1307,8 +1307,8 @@ extern struct task_struct init_task;
extern struct mm_struct init_mm;
-#define find_task_by_pid(nr) find_task_by_pid_type(PIDTYPE_PID, nr)
-extern struct task_struct *find_task_by_pid_type(int type, int pid);
+#define find_task_by_pid(nr) find_task_by_ref_type(REFTYPE_PID, nr)
+extern struct task_struct *find_task_by_ref_type(int type, int pid);
extern void __set_special_pids(pid_t session, pid_t pgrp);
/* per-UID process charging. */
@@ -1365,12 +1365,12 @@ extern int send_sig_info(int, struct sig
extern int send_group_sig_info(int, struct siginfo *, struct task_struct *);
extern int force_sigsegv(int, struct task_struct *);
extern int force_sig_info(int, struct siginfo *, struct task_struct *);
-extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
-extern int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
-extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
-extern int kill_pid_info_as_uid(int, struct siginfo *, struct pid *, uid_t, uid_t, u32);
-extern int kill_pgrp(struct pid *pid, int sig, int priv);
-extern int kill_pid(struct pid *pid, int sig, int priv);
+extern int __kill_pgrp_info(int sig, struct siginfo *info, struct task_ref *pgrp);
+extern int kill_pgrp_info(int sig, struct siginfo *info, struct task_ref *pgrp);
+extern int kill_pid_info(int sig, struct siginfo *info, struct task_ref *pid);
+extern int kill_pid_info_as_uid(int, struct siginfo *, struct task_ref *, uid_t, uid_t, u32);
+extern int kill_pgrp(struct task_ref *tref, int sig, int priv);
+extern int kill_pid(struct task_ref *tref, int sig, int priv);
extern int kill_proc_info(int, struct siginfo *, pid_t);
extern void do_notify_parent(struct task_struct *, int);
extern void do_notify_parent_cldstop(struct task_struct *, int);
@@ -1388,7 +1388,7 @@ extern int do_sigaltstack(const stack_t
static inline int kill_cad_pid(int sig, int priv)
{
- return kill_pid(cad_pid, sig, priv);
+ return kill_pid(cad_tref, sig, priv);
}
/* These can be the second arg to send_sig_info/send_group_sig_info. */
diff -puN include/linux/smb_fs_sb.h~rename-struct-pid include/linux/smb_fs_sb.h
--- lxc/include/linux/smb_fs_sb.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/smb_fs_sb.h 2007-04-10 16:18:30.000000000 -0700
@@ -55,7 +55,7 @@ struct smb_sb_info {
* generation is incremented.
*/
unsigned int generation;
- struct pid *conn_pid;
+ struct task_ref *conn_tref;
struct smb_conn_opt opt;
wait_queue_head_t conn_wq;
int conn_complete;
diff -puN include/linux/tty.h~rename-struct-pid include/linux/tty.h
--- lxc/include/linux/tty.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/tty.h 2007-04-10 16:18:30.000000000 -0700
@@ -197,8 +197,8 @@ struct tty_struct {
struct mutex termios_mutex;
struct ktermios *termios, *termios_locked;
char name[64];
- struct pid *pgrp;
- struct pid *session;
+ struct task_ref *pgrp;
+ struct task_ref *session;
unsigned long flags;
int count;
struct winsize winsize;
diff -puN include/linux/vt_kern.h~rename-struct-pid include/linux/vt_kern.h
--- lxc/include/linux/vt_kern.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/include/linux/vt_kern.h 2007-04-10 16:18:30.000000000 -0700
@@ -87,7 +87,7 @@ extern char vt_dont_switch;
struct vt_spawn_console {
spinlock_t lock;
- struct pid *pid;
+ struct task_ref *tref;
int sig;
};
extern struct vt_spawn_console vt_spawn_con;
diff -puN drivers/char/keyboard.c~rename-struct-pid drivers/char/keyboard.c
--- lxc/drivers/char/keyboard.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/char/keyboard.c 2007-04-10 16:18:30.000000000 -0700
@@ -110,7 +110,7 @@ static struct kbd_struct *kbd = kbd_tabl
struct vt_spawn_console vt_spawn_con = {
.lock = SPIN_LOCK_UNLOCKED,
- .pid = NULL,
+ .tref = NULL,
.sig = 0,
};
@@ -559,10 +559,10 @@ static void fn_compose(struct vc_data *v
static void fn_spawn_con(struct vc_data *vc)
{
spin_lock(&vt_spawn_con.lock);
- if (vt_spawn_con.pid)
- if (kill_pid(vt_spawn_con.pid, vt_spawn_con.sig, 1)) {
- put_pid(vt_spawn_con.pid);
- vt_spawn_con.pid = NULL;
+ if (vt_spawn_con.tref)
+ if (kill_pid(vt_spawn_con.tref, vt_spawn_con.sig, 1)) {
+ put_task_ref(vt_spawn_con.tref);
+ vt_spawn_con.tref = NULL;
}
spin_unlock(&vt_spawn_con.lock);
}
diff -puN drivers/char/n_r3964.c~rename-struct-pid drivers/char/n_r3964.c
--- lxc/drivers/char/n_r3964.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/char/n_r3964.c 2007-04-10 16:18:30.000000000 -0700
@@ -119,8 +119,8 @@ static void transmit_block(struct r3964_
static void receive_char(struct r3964_info *pInfo, const unsigned char c);
static void receive_error(struct r3964_info *pInfo, const char flag);
static void on_timeout(unsigned long priv);
-static int enable_signals(struct r3964_info *pInfo, struct pid *pid, int arg);
-static int read_telegram(struct r3964_info *pInfo, struct pid *pid,
+static int enable_signals(struct r3964_info *pInfo, struct task_ref *tref, int arg);
+static int read_telegram(struct r3964_info *pInfo, struct task_ref *tref,
unsigned char __user * buf);
static void add_msg(struct r3964_client_info *pClient, int msg_id, int arg,
int error_code, struct r3964_block_header *pBlock);
@@ -745,19 +745,19 @@ static void on_timeout(unsigned long pri
}
static struct r3964_client_info *findClient(struct r3964_info *pInfo,
- struct pid *pid)
+ struct task_ref *tref)
{
struct r3964_client_info *pClient;
for (pClient = pInfo->firstClient; pClient; pClient = pClient->next) {
- if (pClient->pid == pid) {
+ if (pClient->tref == tref) {
return pClient;
}
}
return NULL;
}
-static int enable_signals(struct r3964_info *pInfo, struct pid *pid, int arg)
+static int enable_signals(struct r3964_info *pInfo, struct task_ref *tref, int arg)
{
struct r3964_client_info *pClient;
struct r3964_client_info **ppClient;
@@ -769,9 +769,9 @@ static int enable_signals(struct r3964_i
ppClient = &(*ppClient)->next) {
pClient = *ppClient;
- if (pClient->pid == pid) {
+ if (pClient->tref == tref) {
TRACE_PS("removing client %d from client list",
- pid_nr(pid));
+ tref_to_pid(tref));
*ppClient = pClient->next;
while (pClient->msg_count) {
pMsg = remove_msg(pInfo, pClient);
@@ -781,7 +781,7 @@ static int enable_signals(struct r3964_i
"kfree %p", pMsg);
}
}
- put_pid(pClient->pid);
+ put_task_ref(pClient->tref);
kfree(pClient);
TRACE_M("enable_signals - kfree %p", pClient);
return 0;
@@ -789,7 +789,7 @@ static int enable_signals(struct r3964_i
}
return -EINVAL;
} else {
- pClient = findClient(pInfo, pid);
+ pClient = findClient(pInfo, tref);
if (pClient) {
/* update signal options */
pClient->sig_flags = arg;
@@ -801,10 +801,10 @@ static int enable_signals(struct r3964_i
if (pClient == NULL)
return -ENOMEM;
- TRACE_PS("add client %d to client list", pid_nr(pid));
+ TRACE_PS("add client %d to client list", tref_to_pid(tref));
spin_lock_init(&pClient->lock);
pClient->sig_flags = arg;
- pClient->pid = get_pid(pid);
+ pClient->tref = get_pid(tref);
pClient->next = pInfo->firstClient;
pClient->first_msg = NULL;
pClient->last_msg = NULL;
@@ -817,7 +817,7 @@ static int enable_signals(struct r3964_i
return 0;
}
-static int read_telegram(struct r3964_info *pInfo, struct pid *pid,
+static int read_telegram(struct r3964_info *pInfo, struct task_ref *tref,
unsigned char __user * buf)
{
struct r3964_client_info *pClient;
@@ -827,7 +827,7 @@ static int read_telegram(struct r3964_in
return -EINVAL;
}
- pClient = findClient(pInfo, pid);
+ pClient = findClient(pInfo, tref);
if (pClient == NULL) {
return -EINVAL;
}
@@ -899,7 +899,7 @@ queue_the_message:
}
/* Send SIGIO signal to client process: */
if (pClient->sig_flags & R3964_USE_SIGIO) {
- kill_pid(pClient->pid, SIGIO, 1);
+ kill_pid(pClient->tref, SIGIO, 1);
}
}
@@ -933,7 +933,7 @@ static void remove_client_block(struct r
{
struct r3964_block_header *block;
- TRACE_PS("remove_client_block PID %d", pid_nr(pClient->pid));
+ TRACE_PS("remove_client_block PID %d", tref_to_pid(pClient->tref));
block = pClient->next_block_to_read;
if (block) {
@@ -1037,7 +1037,7 @@ static void r3964_close(struct tty_struc
TRACE_M("r3964_close - msg kfree %p", pMsg);
}
}
- put_pid(pClient->pid);
+ put_task_ref(pClient->tref);
kfree(pClient);
TRACE_M("r3964_close - client kfree %p", pClient);
pClient = pNext;
diff -puN drivers/char/tty_io.c~rename-struct-pid drivers/char/tty_io.c
--- lxc/drivers/char/tty_io.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/char/tty_io.c 2007-04-10 16:18:30.000000000 -0700
@@ -1355,7 +1355,7 @@ static void do_tty_hangup(struct work_st
read_lock(&tasklist_lock);
if (tty->session) {
- do_each_pid_task(tty->session, PIDTYPE_SID, p) {
+ do_each_referenced_task(tty->session, REFTYPE_SID, p) {
spin_lock_irq(&p->sighand->siglock);
if (p->signal->tty == tty)
p->signal->tty = NULL;
@@ -1365,17 +1365,17 @@ static void do_tty_hangup(struct work_st
}
__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
- put_pid(p->signal->tty_old_pgrp); /* A noop */
+ put_task_ref(p->signal->tty_old_pgrp); /* A noop */
if (tty->pgrp)
p->signal->tty_old_pgrp = get_pid(tty->pgrp);
spin_unlock_irq(&p->sighand->siglock);
- } while_each_pid_task(tty->session, PIDTYPE_SID, p);
+ } while_each_referenced_task(tty->session, REFTYPE_SID, p);
}
read_unlock(&tasklist_lock);
tty->flags = 0;
- put_pid(tty->session);
- put_pid(tty->pgrp);
+ put_task_ref(tty->session);
+ put_task_ref(tty->pgrp);
tty->session = NULL;
tty->pgrp = NULL;
tty->ctrl_status = 0;
@@ -1462,12 +1462,12 @@ int tty_hung_up_p(struct file * filp)
EXPORT_SYMBOL(tty_hung_up_p);
-static void session_clear_tty(struct pid *session)
+static void session_clear_tty(struct task_ref *session)
{
struct task_struct *p;
- do_each_pid_task(session, PIDTYPE_SID, p) {
+ do_each_referenced_task(session, REFTYPE_SID, p) {
proc_clear_tty(p);
- } while_each_pid_task(session, PIDTYPE_SID, p);
+ } while_each_referenced_task(session, REFTYPE_SID, p);
}
/**
@@ -1497,7 +1497,7 @@ static void session_clear_tty(struct pid
void disassociate_ctty(int on_exit)
{
struct tty_struct *tty;
- struct pid *tty_pgrp = NULL;
+ struct task_ref *tty_pgrp = NULL;
lock_kernel();
@@ -1510,7 +1510,7 @@ void disassociate_ctty(int on_exit)
if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
tty_vhangup(tty);
} else if (on_exit) {
- struct pid *old_pgrp;
+ struct task_ref *old_pgrp;
spin_lock_irq(¤t->sighand->siglock);
old_pgrp = current->signal->tty_old_pgrp;
current->signal->tty_old_pgrp = NULL;
@@ -1518,7 +1518,7 @@ void disassociate_ctty(int on_exit)
if (old_pgrp) {
kill_pgrp(old_pgrp, SIGHUP, on_exit);
kill_pgrp(old_pgrp, SIGCONT, on_exit);
- put_pid(old_pgrp);
+ put_task_ref(old_pgrp);
}
mutex_unlock(&tty_mutex);
unlock_kernel();
@@ -1528,11 +1528,11 @@ void disassociate_ctty(int on_exit)
kill_pgrp(tty_pgrp, SIGHUP, on_exit);
if (!on_exit)
kill_pgrp(tty_pgrp, SIGCONT, on_exit);
- put_pid(tty_pgrp);
+ put_task_ref(tty_pgrp);
}
spin_lock_irq(¤t->sighand->siglock);
- put_pid(current->signal->tty_old_pgrp);
+ put_task_ref(current->signal->tty_old_pgrp);
current->signal->tty_old_pgrp = NULL;
spin_unlock_irq(¤t->sighand->siglock);
@@ -1540,8 +1540,8 @@ void disassociate_ctty(int on_exit)
/* It is possible that do_tty_hangup has free'd this tty */
tty = get_current_tty();
if (tty) {
- put_pid(tty->session);
- put_pid(tty->pgrp);
+ put_task_ref(tty->session);
+ put_task_ref(tty->pgrp);
tty->session = NULL;
tty->pgrp = NULL;
} else {
@@ -2757,18 +2757,18 @@ static int tty_fasync(int fd, struct fil
return retval;
if (on) {
- enum pid_type type;
- struct pid *pid;
+ enum task_ref_type type;
+ struct task_ref *tref;
if (!waitqueue_active(&tty->read_wait))
tty->minimum_to_wake = 1;
if (tty->pgrp) {
- pid = tty->pgrp;
- type = PIDTYPE_PGID;
+ tref = tty->pgrp;
+ type = REFTYPE_PGID;
} else {
- pid = task_pid(current);
- type = PIDTYPE_PID;
+ tref = task_pid(current);
+ type = REFTYPE_PID;
}
- retval = __f_setown(filp, pid, type, 0);
+ retval = __f_setown(filp, tref, type, 0);
if (retval)
return retval;
} else {
@@ -3014,7 +3014,7 @@ static int tiocgpgrp(struct tty_struct *
*/
if (tty == real_tty && current->signal->tty != real_tty)
return -ENOTTY;
- return put_user(pid_nr(real_tty->pgrp), p);
+ return put_user(tref_to_pid(real_tty->pgrp), p);
}
/**
@@ -3031,7 +3031,7 @@ static int tiocgpgrp(struct tty_struct *
static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
{
- struct pid *pgrp;
+ struct task_ref *pgrp;
pid_t pgrp_nr;
int retval = tty_check_change(real_tty);
@@ -3048,7 +3048,7 @@ static int tiocspgrp(struct tty_struct *
if (pgrp_nr < 0)
return -EINVAL;
rcu_read_lock();
- pgrp = find_pid(pgrp_nr);
+ pgrp = find_task(pgrp_nr);
retval = -ESRCH;
if (!pgrp)
goto out_unlock;
@@ -3056,7 +3056,7 @@ static int tiocspgrp(struct tty_struct *
if (session_of_pgrp(pgrp) != task_session(current))
goto out_unlock;
retval = 0;
- put_pid(real_tty->pgrp);
+ put_task_ref(real_tty->pgrp);
real_tty->pgrp = get_pid(pgrp);
out_unlock:
rcu_read_unlock();
@@ -3085,7 +3085,7 @@ static int tiocgsid(struct tty_struct *t
return -ENOTTY;
if (!real_tty->session)
return -ENOTTY;
- return put_user(pid_nr(real_tty->session), p);
+ return put_user(tref_to_pid(real_tty->session), p);
}
/**
@@ -3383,7 +3383,7 @@ void __do_SAK(struct tty_struct *tty)
tty_hangup(tty);
#else
struct task_struct *g, *p;
- struct pid *session;
+ struct task_ref *session;
int i;
struct file *filp;
struct fdtable *fdt;
@@ -3399,12 +3399,12 @@ void __do_SAK(struct tty_struct *tty)
read_lock(&tasklist_lock);
/* Kill the entire session */
- do_each_pid_task(session, PIDTYPE_SID, p) {
+ do_each_referenced_task(session, REFTYPE_SID, p) {
printk(KERN_NOTICE "SAK: killed process %d"
" (%s): process_session(p)==tty->session\n",
p->pid, p->comm);
send_sig(SIGKILL, p, 1);
- } while_each_pid_task(session, PIDTYPE_SID, p);
+ } while_each_referenced_task(session, REFTYPE_SID, p);
/* Now kill any processes that happen to have the
* tty open.
*/
@@ -3849,12 +3849,12 @@ static void __proc_set_tty(struct task_s
{
if (tty) {
/* We should not have a session or pgrp to here but.... */
- put_pid(tty->session);
- put_pid(tty->pgrp);
+ put_task_ref(tty->session);
+ put_task_ref(tty->pgrp);
tty->session = get_pid(task_session(tsk));
tty->pgrp = get_pid(task_pgrp(tsk));
}
- put_pid(tsk->signal->tty_old_pgrp);
+ put_task_ref(tsk->signal->tty_old_pgrp);
tsk->signal->tty = tty;
tsk->signal->tty_old_pgrp = NULL;
}
diff -puN drivers/char/vt.c~rename-struct-pid drivers/char/vt.c
--- lxc/drivers/char/vt.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/char/vt.c 2007-04-10 16:18:30.000000000 -0700
@@ -903,7 +903,7 @@ void vc_deallocate(unsigned int currcons
if (vc_cons_allocated(currcons)) {
struct vc_data *vc = vc_cons[currcons].d;
vc->vc_sw->con_deinit(vc);
- put_pid(vc->vt_pid);
+ put_task_ref(vc->vt_tref);
module_put(vc->vc_sw->owner);
if (vc->vc_kmalloced)
kfree(vc->vc_screenbuf);
diff -puN drivers/char/vt_ioctl.c~rename-struct-pid drivers/char/vt_ioctl.c
--- lxc/drivers/char/vt_ioctl.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/char/vt_ioctl.c 2007-04-10 16:18:30.000000000 -0700
@@ -651,8 +651,8 @@ int vt_ioctl(struct tty_struct *tty, str
return -EINVAL;
spin_lock_irq(&vt_spawn_con.lock);
- put_pid(vt_spawn_con.pid);
- vt_spawn_con.pid = get_pid(task_pid(current));
+ put_task_ref(vt_spawn_con.tref);
+ vt_spawn_con.tref = get_pid(task_pid(current));
vt_spawn_con.sig = arg;
spin_unlock_irq(&vt_spawn_con.lock);
return 0;
@@ -672,8 +672,8 @@ int vt_ioctl(struct tty_struct *tty, str
vc->vt_mode = tmp;
/* the frsig is ignored, so we set it to 0 */
vc->vt_mode.frsig = 0;
- put_pid(vc->vt_pid);
- vc->vt_pid = get_pid(task_pid(current));
+ put_task_ref(vc->vt_tref);
+ vc->vt_tref = get_pid(task_pid(current));
/* no switch is required -- saw@shade.msu.ru */
vc->vt_newvt = -1;
release_console_sem();
@@ -1076,8 +1076,8 @@ void reset_vc(struct vc_data *vc)
vc->vt_mode.relsig = 0;
vc->vt_mode.acqsig = 0;
vc->vt_mode.frsig = 0;
- put_pid(vc->vt_pid);
- vc->vt_pid = NULL;
+ put_task_ref(vc->vt_tref);
+ vc->vt_tref = NULL;
vc->vt_newvt = -1;
if (!in_interrupt()) /* Via keyboard.c:SAK() - akpm */
reset_palette(vc);
@@ -1150,7 +1150,7 @@ static void complete_change_console(stru
* tell us if the process has gone or something else
* is awry
*/
- if (kill_pid(vc->vt_pid, vc->vt_mode.acqsig, 1) != 0) {
+ if (kill_pid(vc->vt_tref, vc->vt_mode.acqsig, 1) != 0) {
/*
* The controlling process has died, so we revert back to
* normal operation. In this case, we'll also change back
@@ -1210,7 +1210,7 @@ void change_console(struct vc_data *new_
* tell us if the process has gone or something else
* is awry
*/
- if (kill_pid(vc->vt_pid, vc->vt_mode.relsig, 1) == 0) {
+ if (kill_pid(vc->vt_tref, vc->vt_mode.relsig, 1) == 0) {
/*
* It worked. Mark the vt to switch to and
* return. The process needs to send us a
diff -puN drivers/net/tun.c~rename-struct-pid drivers/net/tun.c
--- lxc/drivers/net/tun.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/net/tun.c 2007-04-10 16:18:30.000000000 -0700
@@ -713,7 +713,7 @@ static int tun_chr_fasync(int fd, struct
return ret;
if (on) {
- ret = __f_setown(file, task_pid(current), PIDTYPE_PID, 0);
+ ret = __f_setown(file, task_pid(current), REFTYPE_PID, 0);
if (ret)
return ret;
tun->flags |= TUN_FASYNC;
diff -puN drivers/s390/char/fs3270.c~rename-struct-pid drivers/s390/char/fs3270.c
--- lxc/drivers/s390/char/fs3270.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/s390/char/fs3270.c 2007-04-10 16:18:30.000000000 -0700
@@ -27,7 +27,7 @@ static struct raw3270_fn fs3270_fn;
struct fs3270 {
struct raw3270_view view;
- struct pid *fs_pid; /* Pid of controlling program. */
+ struct task_ref *fs_tref; /* Pid of controlling program. */
int read_command; /* ccw command to use for reads. */
int write_command; /* ccw command to use for writes. */
int attention; /* Got attention. */
@@ -484,7 +484,7 @@ fs3270_close(struct inode *inode, struct
fp = filp->private_data;
filp->private_data = NULL;
if (fp) {
- put_pid(fp->fs_pid);
+ put_task_ref(fp->fs_pid);
fp->fs_pid = NULL;
raw3270_reset(&fp->view);
raw3270_put_view(&fp->view);
diff -puN drivers/usb/core/devio.c~rename-struct-pid drivers/usb/core/devio.c
--- lxc/drivers/usb/core/devio.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/usb/core/devio.c 2007-04-10 16:18:30.000000000 -0700
@@ -64,7 +64,7 @@ DEFINE_MUTEX(usbfs_mutex);
struct async {
struct list_head asynclist;
struct dev_state *ps;
- struct pid *pid;
+ struct task_ref *tref;
uid_t uid, euid;
unsigned int signr;
unsigned int ifnum;
@@ -224,7 +224,7 @@ static struct async *alloc_async(unsigne
static void free_async(struct async *as)
{
- put_pid(as->pid);
+ put_task_ref(as->tref);
kfree(as->urb->transfer_buffer);
kfree(as->urb->setup_packet);
usb_free_urb(as->urb);
@@ -317,7 +317,7 @@ static void async_completed(struct urb *
sinfo.si_errno = as->urb->status;
sinfo.si_code = SI_ASYNCIO;
sinfo.si_addr = as->userurb;
- kill_pid_info_as_uid(as->signr, &sinfo, as->pid, as->uid,
+ kill_pid_info_as_uid(as->signr, &sinfo, as->tref, as->uid,
as->euid, as->secid);
}
snoop(&urb->dev->dev, "urb complete\n");
@@ -580,7 +580,7 @@ static int usbdev_open(struct inode *ino
INIT_LIST_HEAD(&ps->async_completed);
init_waitqueue_head(&ps->wait);
ps->discsignr = 0;
- ps->disc_pid = get_pid(task_pid(current));
+ ps->disc_tref = get_pid(task_pid(current));
ps->disc_uid = current->uid;
ps->disc_euid = current->euid;
ps->disccontext = NULL;
@@ -618,7 +618,7 @@ static int usbdev_release(struct inode *
usb_autosuspend_device(dev);
usb_unlock_device(dev);
usb_put_dev(dev);
- put_pid(ps->disc_pid);
+ put_task_ref(ps->disc_tref);
kfree(ps);
return 0;
}
@@ -1074,7 +1074,7 @@ static int proc_do_submiturb(struct dev_
as->userbuffer = NULL;
as->signr = uurb->signr;
as->ifnum = ifnum;
- as->pid = get_pid(task_pid(current));
+ as->tref = get_pid(task_pid(current));
as->uid = current->uid;
as->euid = current->euid;
security_task_getsecid(current, &as->secid);
diff -puN drivers/usb/core/inode.c~rename-struct-pid drivers/usb/core/inode.c
--- lxc/drivers/usb/core/inode.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/usb/core/inode.c 2007-04-10 16:18:30.000000000 -0700
@@ -698,7 +698,7 @@ static void usbfs_remove_device(struct u
sinfo.si_errno = EPIPE;
sinfo.si_code = SI_ASYNCIO;
sinfo.si_addr = ds->disccontext;
- kill_pid_info_as_uid(ds->discsignr, &sinfo, ds->disc_pid, ds->disc_uid, ds->disc_euid, ds->secid);
+ kill_pid_info_as_uid(ds->discsignr, &sinfo, ds->disc_tref, ds->disc_uid, ds->disc_euid, ds->secid);
}
}
}
diff -puN drivers/usb/core/usb.h~rename-struct-pid drivers/usb/core/usb.h
--- lxc/drivers/usb/core/usb.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/drivers/usb/core/usb.h 2007-04-10 16:18:30.000000000 -0700
@@ -135,7 +135,7 @@ struct dev_state {
struct list_head async_completed;
wait_queue_head_t wait; /* wake up if a request completed */
unsigned int discsignr;
- struct pid *disc_pid;
+ struct task_ref *disc_tref;
uid_t disc_uid, disc_euid;
void __user *disccontext;
unsigned long ifclaimed;
diff -puN files~rename-struct-pid files
--- lxc/files~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/files 2007-04-10 16:18:30.000000000 -0700
@@ -1,38 +1,4 @@
-drivers/net/tun.c tun_chr_fasync 716 ret = __f_setown(file, task_pid(current), PIDTYPE_PID, 0);
-fs/dnotify.c fcntl_dirnotify 95 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
-fs/fcntl.c f_setown 286 type = PIDTYPE_PID;
-fs/fcntl.c f_setown 288 type = PIDTYPE_PGID;
-fs/fcntl.c f_delown 301 f_modown(filp, NULL, PIDTYPE_PID, 0, 0, 1);
-fs/fcntl.c f_getown 309 if (filp->f_owner.task_ref_type == PIDTYPE_PGID)
-fs/ioprio.c sys_ioprio_set 105 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-fs/ioprio.c sys_ioprio_set 109 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-fs/ioprio.c sys_ioprio_get 192 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-fs/ioprio.c sys_ioprio_get 200 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-fs/locks.c fcntl_setlease 1517 error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
-fs/proc/base.c proc_loginuid_write 815 if (current != pid_task(proc_pid(inode), PIDTYPE_PID))
-fs/proc/base.c proc_pid_make_inode 1096 ei->pid = get_task_pid(task, PIDTYPE_PID);
-fs/proc/base.c pid_getattr 1125 task = pid_task(proc_pid(inode), PIDTYPE_PID);
-fs/proc/base.c pid_delete_dentry 1182 return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
-fs/proc/base.c proc_base_instantiate 1919 ei->pid = get_task_pid(task, PIDTYPE_PID);
-fs/proc/base.c next_tgid 2228 task = pid_task(pid, PIDTYPE_PID);
-fs/proc/internal.h get_proc_task 69 return get_pid_task(proc_pid(inode), PIDTYPE_PID);
-fs/proc/task_mmu.c m_start 396 priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
-fs/proc/task_nommu.c m_start 163 priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
-kernel/capability.c cap_set_pg 105 do_each_pid_task(pgrp, PIDTYPE_PGID, g) {
-kernel/capability.c cap_set_pg 118 } while_each_pid_task(pgrp, PIDTYPE_PGID, g);
-kernel/cpuset.c proc_cpuset_show 2553 tsk = get_pid_task(pid, PIDTYPE_PID);
-kernel/futex.c futex_fd 2082 err = __f_setown(filp, task_pid(current), PIDTYPE_PID, 1);
-kernel/pid.c alloc_pid 222 for (type = 0; type < PIDTYPE_MAX; ++type)
-kernel/pid.c detach_pid 279 for (tmp = PIDTYPE_MAX; --tmp >= 0; )
-kernel/signal.c __kill_pgrp_info 1234 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-kernel/signal.c __kill_pgrp_info 1238 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-kernel/signal.c kill_pid_info 1262 p = pid_task(pid, PIDTYPE_PID);
-kernel/signal.c kill_pid_info_as_uid 1294 p = pid_task(pid, PIDTYPE_PID);
-kernel/sys.c sys_setpriority 687 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-kernel/sys.c sys_setpriority 689 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-kernel/sys.c sys_getpriority 747 do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
-kernel/sys.c sys_getpriority 751 } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
-kernel/sys.c sys_setpgid 1477 find_task_by_pid_type(PIDTYPE_PGID, pgid);
-kernel/sys.c sys_setpgid 1488 detach_pid(p, PIDTYPE_PGID);
-kernel/sys.c sys_setpgid 1490 attach_pid(p, PIDTYPE_PGID, find_pid(pgid));
-kernel/sys.c sys_setsid 1574 if (session > 1 && find_task_by_pid_type(PIDTYPE_PGID, session))
+include/linux/sched.h <global> 1311 extern struct task_struct *find_task_by_tref_type(int type, int pid);
+include/linux/sched.h find_task_by_tref 1310 #define find_task_by_tref(nr) find_task_by_tref_type(REFTYPE_PID, nr)
+kernel/sys.c sys_setpgid 1477 find_task_by_tref_type(REFTYPE_PGID, pgid);
+kernel/sys.c sys_setsid 1574 if (session > 1 && find_task_by_tref_type(REFTYPE_PGID, session))
diff -puN fs/autofs/autofs_i.h~rename-struct-pid fs/autofs/autofs_i.h
--- lxc/fs/autofs/autofs_i.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/autofs/autofs_i.h 2007-04-10 16:18:30.000000000 -0700
@@ -101,7 +101,7 @@ struct autofs_symlink {
struct autofs_sb_info {
u32 magic;
struct file *pipe;
- struct pid *oz_pgrp;
+ struct task_ref *oz_pgrp;
int catatonic;
struct super_block *sb;
unsigned long exp_timeout;
diff -puN fs/autofs/inode.c~rename-struct-pid fs/autofs/inode.c
--- lxc/fs/autofs/inode.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/autofs/inode.c 2007-04-10 16:18:30.000000000 -0700
@@ -37,7 +37,7 @@ void autofs_kill_sb(struct super_block *
if (!sbi->catatonic)
autofs_catatonic_mode(sbi); /* Free wait queues, close pipe */
- put_pid(sbi->oz_pgrp);
+ put_task_ref(sbi->oz_pgrp);
autofs_hash_nuke(sbi);
for (n = 0; n < AUTOFS_MAX_SYMLINKS; n++) {
@@ -216,7 +216,7 @@ fail_fput:
printk("autofs: pipe file descriptor does not contain proper ops\n");
fput(pipe);
fail_put_pid:
- put_pid(sbi->oz_pgrp);
+ put_task_ref(sbi->oz_pgrp);
fail_dput:
dput(root);
goto fail_free;
diff -puN fs/autofs/root.c~rename-struct-pid fs/autofs/root.c
--- lxc/fs/autofs/root.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/autofs/root.c 2007-04-10 16:18:30.000000000 -0700
@@ -214,7 +214,7 @@ static struct dentry *autofs_root_lookup
oz_mode = autofs_oz_mode(sbi);
DPRINTK(("autofs_lookup: pid = %u, pgrp = %u, catatonic = %d, "
- "oz_mode = %d\n", pid_nr(task_pid(current)),
+ "oz_mode = %d\n", tref_to_pid(task_pid(current)),
process_group(current), sbi->catatonic,
oz_mode));
diff -puN fs/compat.c~rename-struct-pid fs/compat.c
--- lxc/fs/compat.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/compat.c 2007-04-10 16:18:30.000000000 -0700
@@ -738,7 +738,7 @@ static void *do_ncp_super_data_conv(void
n->gid = c_n->gid;
n->uid = c_n->uid;
memmove (n->mounted_vol, c_n->mounted_vol, (sizeof (c_n->mounted_vol) + 3 * sizeof (unsigned int)));
- n->wdog_pid = c_n->wdog_pid;
+ n->wdog_tref = c_n->wdog_tref;
n->mounted_uid = c_n->mounted_uid;
} else if (version == 4) {
struct compat_ncp_mount_data_v4 *c_n = raw_data;
@@ -751,7 +751,7 @@ static void *do_ncp_super_data_conv(void
n->retry_count = c_n->retry_count;
n->time_out = c_n->time_out;
n->ncp_fd = c_n->ncp_fd;
- n->wdog_pid = c_n->wdog_pid;
+ n->wdog_tref = c_n->wdog_tref;
n->mounted_uid = c_n->mounted_uid;
n->flags = c_n->flags;
} else if (version != 5) {
diff -puN fs/dnotify.c~rename-struct-pid fs/dnotify.c
--- lxc/fs/dnotify.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/dnotify.c 2007-04-10 16:18:30.000000000 -0700
@@ -92,7 +92,7 @@ int fcntl_dirnotify(int fd, struct file
prev = &odn->dn_next;
}
- error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
+ error = __f_setown(filp, task_pid(current), REFTYPE_PID, 0);
if (error)
goto out_free;
diff -puN fs/exec.c~rename-struct-pid fs/exec.c
--- lxc/fs/exec.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/exec.c 2007-04-10 16:18:30.000000000 -0700
@@ -708,11 +708,11 @@ static int de_thread(struct task_struct
* Note: The old leader also uses this pid until release_task
* is called. Odd but simple and correct.
*/
- detach_pid(tsk, PIDTYPE_PID);
+ detach_task_ref(tsk, REFTYPE_PID);
tsk->pid = leader->pid;
- attach_pid(tsk, PIDTYPE_PID, find_pid(tsk->pid));
- transfer_pid(leader, tsk, PIDTYPE_PGID);
- transfer_pid(leader, tsk, PIDTYPE_SID);
+ attach_task_ref(tsk, REFTYPE_PID, find_task(tsk->pid));
+ transfer_task_ref(leader, tsk, REFTYPE_PGID);
+ transfer_task_ref(leader, tsk, REFTYPE_SID);
list_replace_rcu(&leader->tasks, &tsk->tasks);
tsk->group_leader = tsk;
diff -puN fs/fcntl.c~rename-struct-pid fs/fcntl.c
--- lxc/fs/fcntl.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/fcntl.c 2007-04-10 16:18:30.000000000 -0700
@@ -249,21 +249,22 @@ static int setfl(int fd, struct file * f
return error;
}
-static void f_modown(struct file *filp, struct pid *pid, enum pid_type type,
- uid_t uid, uid_t euid, int force)
+static void f_modown(struct file *filp, struct task_ref *tref,
+ enum task_ref_type type,
+ uid_t uid, uid_t euid, int force)
{
write_lock_irq(&filp->f_owner.lock);
- if (force || !filp->f_owner.pid) {
- put_pid(filp->f_owner.pid);
- filp->f_owner.pid = get_pid(pid);
- filp->f_owner.pid_type = type;
+ if (force || !filp->f_owner.tref) {
+ put_task_ref(filp->f_owner.tref);
+ filp->f_owner.tref = get_pid(tref);
+ filp->f_owner.task_ref_type = type;
filp->f_owner.uid = uid;
filp->f_owner.euid = euid;
}
write_unlock_irq(&filp->f_owner.lock);
}
-int __f_setown(struct file *filp, struct pid *pid, enum pid_type type,
+int __f_setown(struct file *filp, struct task_ref *tref, enum task_ref_type type,
int force)
{
int err;
@@ -272,25 +273,25 @@ int __f_setown(struct file *filp, struct
if (err)
return err;
- f_modown(filp, pid, type, current->uid, current->euid, force);
+ f_modown(filp, tref, type, current->uid, current->euid, force);
return 0;
}
EXPORT_SYMBOL(__f_setown);
int f_setown(struct file *filp, unsigned long arg, int force)
{
- enum pid_type type;
- struct pid *pid;
+ enum task_ref_type type;
+ struct task_ref *tref;
int who = arg;
int result;
- type = PIDTYPE_PID;
+ type = REFTYPE_PID;
if (who < 0) {
- type = PIDTYPE_PGID;
+ type = REFTYPE_PGID;
who = -who;
}
rcu_read_lock();
- pid = find_pid(who);
- result = __f_setown(filp, pid, type, force);
+ tref = find_task(who);
+ result = __f_setown(filp, tref, type, force);
rcu_read_unlock();
return result;
}
@@ -298,15 +299,15 @@ EXPORT_SYMBOL(f_setown);
void f_delown(struct file *filp)
{
- f_modown(filp, NULL, PIDTYPE_PID, 0, 0, 1);
+ f_modown(filp, NULL, REFTYPE_PID, 0, 0, 1);
}
pid_t f_getown(struct file *filp)
{
pid_t pid;
read_lock(&filp->f_owner.lock);
- pid = pid_nr(filp->f_owner.pid);
- if (filp->f_owner.pid_type == PIDTYPE_PGID)
+ pid = tref_to_pid(filp->f_owner.tref);
+ if (filp->f_owner.task_ref_type == REFTYPE_PGID)
pid = -pid;
read_unlock(&filp->f_owner.lock);
return pid;
@@ -501,19 +502,19 @@ static void send_sigio_to_task(struct ta
void send_sigio(struct fown_struct *fown, int fd, int band)
{
struct task_struct *p;
- enum pid_type type;
- struct pid *pid;
+ enum task_ref_type type;
+ struct task_ref *tref;
read_lock(&fown->lock);
- type = fown->pid_type;
- pid = fown->pid;
- if (!pid)
+ type = fown->task_ref_type;
+ tref = fown->tref;
+ if (!tref)
goto out_unlock_fown;
read_lock(&tasklist_lock);
- do_each_pid_task(pid, type, p) {
+ do_each_referenced_task(tref, type, p) {
send_sigio_to_task(p, fown, fd, band);
- } while_each_pid_task(pid, type, p);
+ } while_each_referenced_task(tref, type, p);
read_unlock(&tasklist_lock);
out_unlock_fown:
read_unlock(&fown->lock);
@@ -529,22 +530,22 @@ static void send_sigurg_to_task(struct t
int send_sigurg(struct fown_struct *fown)
{
struct task_struct *p;
- enum pid_type type;
- struct pid *pid;
+ enum task_ref_type type;
+ struct task_ref *tref;
int ret = 0;
read_lock(&fown->lock);
- type = fown->pid_type;
- pid = fown->pid;
- if (!pid)
+ type = fown->task_ref_type;
+ tref = fown->tref;
+ if (!tref)
goto out_unlock_fown;
ret = 1;
read_lock(&tasklist_lock);
- do_each_pid_task(pid, type, p) {
+ do_each_referenced_task(tref, type, p) {
send_sigurg_to_task(p, fown);
- } while_each_pid_task(pid, type, p);
+ } while_each_referenced_task(tref, type, p);
read_unlock(&tasklist_lock);
out_unlock_fown:
read_unlock(&fown->lock);
diff -puN fs/file_table.c~rename-struct-pid fs/file_table.c
--- lxc/fs/file_table.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/file_table.c 2007-04-10 16:18:30.000000000 -0700
@@ -175,7 +175,7 @@ void fastcall __fput(struct file *file)
fops_put(file->f_op);
if (file->f_mode & FMODE_WRITE)
put_write_access(inode);
- put_pid(file->f_owner.pid);
+ put_task_ref(file->f_owner.tref);
file_kill(file);
file->f_path.dentry = NULL;
file->f_path.mnt = NULL;
diff -puN fs/ioprio.c~rename-struct-pid fs/ioprio.c
--- lxc/fs/ioprio.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/ioprio.c 2007-04-10 16:18:30.000000000 -0700
@@ -60,7 +60,7 @@ asmlinkage long sys_ioprio_set(int which
int data = IOPRIO_PRIO_DATA(ioprio);
struct task_struct *p, *g;
struct user_struct *user;
- struct pid *pgrp;
+ struct task_ref *pgrp;
int ret;
switch (class) {
@@ -101,12 +101,12 @@ asmlinkage long sys_ioprio_set(int which
if (!who)
pgrp = task_pgrp(current);
else
- pgrp = find_pid(who);
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ pgrp = find_task(who);
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
ret = set_task_ioprio(p, ioprio);
if (ret)
break;
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
break;
case IOPRIO_WHO_USER:
if (!who)
@@ -170,7 +170,7 @@ asmlinkage long sys_ioprio_get(int which
{
struct task_struct *g, *p;
struct user_struct *user;
- struct pid *pgrp;
+ struct task_ref *pgrp;
int ret = -ESRCH;
int tmpio;
@@ -188,8 +188,8 @@ asmlinkage long sys_ioprio_get(int which
if (!who)
pgrp = task_pgrp(current);
else
- pgrp = find_pid(who);
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ pgrp = find_task(who);
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
tmpio = get_task_ioprio(p);
if (tmpio < 0)
continue;
@@ -197,7 +197,7 @@ asmlinkage long sys_ioprio_get(int which
ret = tmpio;
else
ret = ioprio_best(ret, tmpio);
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
break;
case IOPRIO_WHO_USER:
if (!who)
@@ -230,4 +230,3 @@ asmlinkage long sys_ioprio_get(int which
read_unlock(&tasklist_lock);
return ret;
}
-
diff -puN fs/locks.c~rename-struct-pid fs/locks.c
--- lxc/fs/locks.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/locks.c 2007-04-10 16:18:30.000000000 -0700
@@ -1514,7 +1514,7 @@ int fcntl_setlease(unsigned int fd, stru
goto out_unlock;
}
- error = __f_setown(filp, task_pid(current), PIDTYPE_PID, 0);
+ error = __f_setown(filp, task_pid(current), REFTYPE_PID, 0);
out_unlock:
unlock_kernel();
return error;
diff -puN fs/ncpfs/inode.c~rename-struct-pid fs/ncpfs/inode.c
--- lxc/fs/ncpfs/inode.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/ncpfs/inode.c 2007-04-10 16:18:30.000000000 -0700
@@ -332,7 +332,7 @@ static int ncp_parse_options(struct ncp_
data->flags = 0;
data->int_flags = 0;
data->mounted_uid = 0;
- data->wdog_pid = NULL;
+ data->wdog_tref = NULL;
data->ncp_fd = ~0;
data->time_out = 10;
data->retry_count = 20;
@@ -373,7 +373,7 @@ static int ncp_parse_options(struct ncp_
data->flags = optint;
break;
case 'w':
- data->wdog_pid = find_get_pid(optint);
+ data->wdog_tref = find_get_pid(optint);
break;
case 'n':
data->ncp_fd = optint;
@@ -394,8 +394,8 @@ static int ncp_parse_options(struct ncp_
}
return 0;
err:
- put_pid(data->wdog_pid);
- data->wdog_pid = NULL;
+ put_task_ref(data->wdog_tref);
+ data->wdog_tref = NULL;
return ret;
}
@@ -414,7 +414,7 @@ static int ncp_fill_super(struct super_b
#endif
struct ncp_entry_info finfo;
- data.wdog_pid = NULL;
+ data.wdog_tref = NULL;
server = kzalloc(sizeof(struct ncp_server), GFP_KERNEL);
if (!server)
return -ENOMEM;
@@ -431,7 +431,7 @@ static int ncp_fill_super(struct super_b
data.flags = md->flags;
data.int_flags = NCP_IMOUNT_LOGGEDIN_POSSIBLE;
data.mounted_uid = md->mounted_uid;
- data.wdog_pid = find_get_pid(md->wdog_pid);
+ data.wdog_tref = find_get_pid(md->wdog_pid);
data.ncp_fd = md->ncp_fd;
data.time_out = md->time_out;
data.retry_count = md->retry_count;
@@ -451,7 +451,7 @@ static int ncp_fill_super(struct super_b
data.flags = md->flags;
data.int_flags = 0;
data.mounted_uid = md->mounted_uid;
- data.wdog_pid = find_get_pid(md->wdog_pid);
+ data.wdog_tref = find_get_pid(md->wdog_pid);
data.ncp_fd = md->ncp_fd;
data.time_out = md->time_out;
data.retry_count = md->retry_count;
@@ -695,7 +695,7 @@ out_fput:
*/
fput(ncp_filp);
out:
- put_pid(data.wdog_pid);
+ put_task_ref(data.wdog_tref);
sb->s_fs_info = NULL;
kfree(server);
return error;
@@ -728,8 +728,8 @@ static void ncp_put_super(struct super_b
if (server->info_filp)
fput(server->info_filp);
fput(server->ncp_filp);
- kill_pid(server->m.wdog_pid, SIGTERM, 1);
- put_pid(server->m.wdog_pid);
+ kill_pid(server->m.wdog_tref, SIGTERM, 1);
+ put_task_ref(server->m.wdog_tref);
kfree(server->priv.data);
kfree(server->auth.object_name);
diff -puN fs/proc/array.c~rename-struct-pid fs/proc/array.c
--- lxc/fs/proc/array.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/array.c 2007-04-10 16:18:30.000000000 -0700
@@ -355,7 +355,7 @@ static int do_task_stat(struct task_stru
struct signal_struct *sig = task->signal;
if (sig->tty) {
- tty_pgrp = pid_nr(sig->tty->pgrp);
+ tty_pgrp = tref_to_pid(sig->tty->pgrp);
tty_nr = new_encode_dev(tty_devnum(sig->tty));
}
diff -puN fs/proc/base.c~rename-struct-pid fs/proc/base.c
--- lxc/fs/proc/base.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/base.c 2007-04-10 16:18:30.000000000 -0700
@@ -812,7 +812,7 @@ static ssize_t proc_loginuid_write(struc
if (!capable(CAP_AUDIT_CONTROL))
return -EPERM;
- if (current != pid_task(proc_pid(inode), PIDTYPE_PID))
+ if (current != pid_task(proc_task_ref(inode), REFTYPE_PID))
return -EPERM;
if (count >= PAGE_SIZE)
@@ -1093,8 +1093,8 @@ static struct inode *proc_pid_make_inode
/*
* grab the reference to task.
*/
- ei->pid = get_task_pid(task, PIDTYPE_PID);
- if (!ei->pid)
+ ei->tref = get_task_ref(task, REFTYPE_PID);
+ if (!ei->tref)
goto out_unlock;
inode->i_uid = 0;
@@ -1122,7 +1122,7 @@ static int pid_getattr(struct vfsmount *
rcu_read_lock();
stat->uid = 0;
stat->gid = 0;
- task = pid_task(proc_pid(inode), PIDTYPE_PID);
+ task = pid_task(proc_task_ref(inode), REFTYPE_PID);
if (task) {
if ((inode->i_mode == (S_IFDIR|S_IRUGO|S_IXUGO)) ||
task_dumpable(task)) {
@@ -1179,7 +1179,7 @@ static int pid_delete_dentry(struct dent
* If so, then don't put the dentry on the lru list,
* kill it immediately.
*/
- return !proc_pid(dentry->d_inode)->tasks[PIDTYPE_PID].first;
+ return !proc_task_ref(dentry->d_inode)->tasks[REFTYPE_PID].first;
}
static struct dentry_operations pid_dentry_operations =
@@ -1537,7 +1537,7 @@ static int proc_fd_permission(struct ino
rv = generic_permission(inode, mask, NULL);
if (rv == 0)
return 0;
- if (task_pid(current) == proc_pid(inode))
+ if (task_pid(current) == proc_task_ref(inode))
rv = 0;
return rv;
}
@@ -1603,7 +1603,7 @@ static const struct inode_operations pro
};
-static struct dentry *proc_pident_instantiate(struct inode *dir,
+static struct dentry *proc_task_refent_instantiate(struct inode *dir,
struct dentry *dentry, struct task_struct *task, const void *ptr)
{
const struct pid_entry *p = ptr;
@@ -1633,7 +1633,7 @@ out:
return error;
}
-static struct dentry *proc_pident_lookup(struct inode *dir,
+static struct dentry *proc_task_refent_lookup(struct inode *dir,
struct dentry *dentry,
const struct pid_entry *ents,
unsigned int nents)
@@ -1663,21 +1663,21 @@ static struct dentry *proc_pident_lookup
if (p > last)
goto out;
- error = proc_pident_instantiate(dir, dentry, task, p);
+ error = proc_task_refent_instantiate(dir, dentry, task, p);
out:
put_task_struct(task);
out_no_task:
return error;
}
-static int proc_pident_fill_cache(struct file *filp, void *dirent,
+static int proc_task_refent_fill_cache(struct file *filp, void *dirent,
filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
{
return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
- proc_pident_instantiate, task, p);
+ proc_task_refent_instantiate, task, p);
}
-static int proc_pident_readdir(struct file *filp,
+static int proc_task_refent_readdir(struct file *filp,
void *dirent, filldir_t filldir,
const struct pid_entry *ents, unsigned int nents)
{
@@ -1721,7 +1721,7 @@ static int proc_pident_readdir(struct fi
p = ents + i;
last = &ents[nents - 1];
while (p <= last) {
- if (proc_pident_fill_cache(filp, dirent, filldir, task, p) < 0)
+ if (proc_task_refent_fill_cache(filp, dirent, filldir, task, p) < 0)
goto out;
filp->f_pos++;
p++;
@@ -1813,7 +1813,7 @@ static const struct pid_entry attr_dir_s
static int proc_attr_dir_readdir(struct file * filp,
void * dirent, filldir_t filldir)
{
- return proc_pident_readdir(filp,dirent,filldir,
+ return proc_task_refent_readdir(filp,dirent,filldir,
attr_dir_stuff,ARRAY_SIZE(attr_dir_stuff));
}
@@ -1825,7 +1825,7 @@ static const struct file_operations proc
static struct dentry *proc_attr_dir_lookup(struct inode *dir,
struct dentry *dentry, struct nameidata *nd)
{
- return proc_pident_lookup(dir, dentry,
+ return proc_task_refent_lookup(dir, dentry,
attr_dir_stuff, ARRAY_SIZE(attr_dir_stuff));
}
@@ -1916,8 +1916,8 @@ static struct dentry *proc_base_instanti
/*
* grab the reference to the task.
*/
- ei->pid = get_task_pid(task, PIDTYPE_PID);
- if (!ei->pid)
+ ei->tref = get_task_ref(task, REFTYPE_PID);
+ if (!ei->tref)
goto out_iput;
inode->i_uid = 0;
@@ -2065,7 +2065,7 @@ static const struct pid_entry tgid_base_
static int proc_tgid_base_readdir(struct file * filp,
void * dirent, filldir_t filldir)
{
- return proc_pident_readdir(filp,dirent,filldir,
+ return proc_task_refent_readdir(filp,dirent,filldir,
tgid_base_stuff,ARRAY_SIZE(tgid_base_stuff));
}
@@ -2075,7 +2075,7 @@ static const struct file_operations proc
};
static struct dentry *proc_tgid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
- return proc_pident_lookup(dir, dentry,
+ return proc_task_refent_lookup(dir, dentry,
tgid_base_stuff, ARRAY_SIZE(tgid_base_stuff));
}
@@ -2217,15 +2217,15 @@ out:
static struct task_struct *next_tgid(unsigned int tgid)
{
struct task_struct *task;
- struct pid *pid;
+ struct task_ref *tref;
rcu_read_lock();
retry:
task = NULL;
- pid = find_ge_pid(tgid);
- if (pid) {
- tgid = pid->nr + 1;
- task = pid_task(pid, PIDTYPE_PID);
+ tref = find_ge_pid(tgid);
+ if (tref) {
+ tgid = tref->pid + 1;
+ task = pid_task(tref, REFTYPE_PID);
/* What we to know is if the pid we have find is the
* pid of a thread_group_leader. Testing for task
* being a thread_group_leader is the obvious thing
@@ -2345,12 +2345,12 @@ static const struct pid_entry tid_base_s
static int proc_tid_base_readdir(struct file * filp,
void * dirent, filldir_t filldir)
{
- return proc_pident_readdir(filp,dirent,filldir,
+ return proc_task_refent_readdir(filp,dirent,filldir,
tid_base_stuff,ARRAY_SIZE(tid_base_stuff));
}
static struct dentry *proc_tid_base_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd){
- return proc_pident_lookup(dir, dentry,
+ return proc_task_refent_lookup(dir, dentry,
tid_base_stuff, ARRAY_SIZE(tid_base_stuff));
}
diff -puN fs/proc/inode.c~rename-struct-pid fs/proc/inode.c
--- lxc/fs/proc/inode.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/inode.c 2007-04-10 16:18:30.000000000 -0700
@@ -62,7 +62,7 @@ static void proc_delete_inode(struct ino
truncate_inode_pages(&inode->i_data, 0);
/* Stop tracking associated processes */
- put_pid(PROC_I(inode)->pid);
+ put_task_ref(PROC_I(inode)->tref);
/* Let go of any associated proc directory entry */
de = PROC_I(inode)->pde;
@@ -91,7 +91,7 @@ static struct inode *proc_alloc_inode(st
ei = (struct proc_inode *)kmem_cache_alloc(proc_inode_cachep, GFP_KERNEL);
if (!ei)
return NULL;
- ei->pid = NULL;
+ ei->tref= NULL;
ei->fd = 0;
ei->op.proc_get_link = NULL;
ei->pde = NULL;
diff -puN fs/proc/internal.h~rename-struct-pid fs/proc/internal.h
--- lxc/fs/proc/internal.h~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/internal.h 2007-04-10 16:18:30.000000000 -0700
@@ -59,14 +59,14 @@ void free_proc_entry(struct proc_dir_ent
int proc_init_inodecache(void);
-static inline struct pid *proc_pid(struct inode *inode)
+static inline struct task_ref *proc_task_ref(struct inode *inode)
{
- return PROC_I(inode)->pid;
+ return PROC_I(inode)->tref;
}
static inline struct task_struct *get_proc_task(struct inode *inode)
{
- return get_pid_task(proc_pid(inode), PIDTYPE_PID);
+ return get_pid_task(proc_task_ref(inode), REFTYPE_PID);
}
static inline int proc_fd(struct inode *inode)
diff -puN fs/proc/root.c~rename-struct-pid fs/proc/root.c
--- lxc/fs/proc/root.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/root.c 2007-04-10 16:18:30.000000000 -0700
@@ -34,8 +34,8 @@ static int proc_get_sb(struct file_syste
*/
struct proc_inode *ei;
ei = PROC_I(proc_mnt->mnt_sb->s_root->d_inode);
- if (!ei->pid)
- ei->pid = find_get_pid(1);
+ if (!ei->tref)
+ ei->tref = find_get_pid(1);
}
return get_sb_single(fs_type, flags, data, proc_fill_super, mnt);
}
diff -puN fs/proc/task_mmu.c~rename-struct-pid fs/proc/task_mmu.c
--- lxc/fs/proc/task_mmu.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/task_mmu.c 2007-04-10 16:18:30.000000000 -0700
@@ -393,7 +393,7 @@ static void *m_start(struct seq_file *m,
if (last_addr == -1UL)
return NULL;
- priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
+ priv->task = get_pid_task(priv->tref, REFTYPE_PID);
if (!priv->task)
return NULL;
@@ -489,7 +489,7 @@ static int do_maps_open(struct inode *in
int ret = -ENOMEM;
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (priv) {
- priv->pid = proc_pid(inode);
+ priv->tref = proc_task_ref(inode);
ret = seq_open(file, ops);
if (!ret) {
struct seq_file *m = file->private_data;
diff -puN fs/proc/task_nommu.c~rename-struct-pid fs/proc/task_nommu.c
--- lxc/fs/proc/task_nommu.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/proc/task_nommu.c 2007-04-10 16:18:30.000000000 -0700
@@ -160,7 +160,7 @@ static void *m_start(struct seq_file *m,
loff_t n = *pos;
/* pin the task and mm whilst we play with them */
- priv->task = get_pid_task(priv->pid, PIDTYPE_PID);
+ priv->task = get_pid_task(priv->pid, REFTYPE_PID);
if (!priv->task)
return NULL;
@@ -214,7 +214,7 @@ static int maps_open(struct inode *inode
priv = kzalloc(sizeof(*priv), GFP_KERNEL);
if (priv) {
- priv->pid = proc_pid(inode);
+ priv->pid = proc_task_ref(inode);
ret = seq_open(file, &proc_pid_maps_ops);
if (!ret) {
struct seq_file *m = file->private_data;
@@ -232,4 +232,3 @@ const struct file_operations proc_maps_o
.llseek = seq_lseek,
.release = seq_release_private,
};
-
diff -puN fs/smbfs/inode.c~rename-struct-pid fs/smbfs/inode.c
--- lxc/fs/smbfs/inode.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/smbfs/inode.c 2007-04-10 16:18:30.000000000 -0700
@@ -481,14 +481,14 @@ smb_put_super(struct super_block *sb)
smb_close_socket(server);
- if (server->conn_pid)
- kill_pid(server->conn_pid, SIGTERM, 1);
+ if (server->conn_tref)
+ kill_pid(server->conn_tref, SIGTERM, 1);
kfree(server->ops);
smb_unload_nls(server);
sb->s_fs_info = NULL;
smb_unlock_server(server);
- put_pid(server->conn_pid);
+ put_task_ref(server->conn_tref);
kfree(server);
}
@@ -538,7 +538,7 @@ static int smb_fill_super(struct super_b
INIT_LIST_HEAD(&server->xmitq);
INIT_LIST_HEAD(&server->recvq);
server->conn_error = 0;
- server->conn_pid = NULL;
+ server->conn_tref = NULL;
server->state = CONN_INVALID; /* no connection yet */
server->generation = 0;
diff -puN fs/smbfs/proc.c~rename-struct-pid fs/smbfs/proc.c
--- lxc/fs/smbfs/proc.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/smbfs/proc.c 2007-04-10 16:18:30.000000000 -0700
@@ -877,7 +877,7 @@ smb_newconn(struct smb_sb_info *server,
goto out_putf;
server->sock_file = filp;
- server->conn_pid = get_pid(task_pid(current));
+ server->conn_tref = get_pid(task_pid(current));
server->opt = *opt;
server->generation += 1;
server->state = CONN_VALID;
@@ -972,7 +972,7 @@ smb_newconn(struct smb_sb_info *server,
VERBOSE("protocol=%d, max_xmit=%d, pid=%d capabilities=0x%x\n",
server->opt.protocol, server->opt.max_xmit,
- pid_nr(server->conn_pid), server->opt.capabilities);
+ tref_to_pid(server->conn_tgid), server->opt.capabilities);
/* FIXME: this really should be done by smbmount. */
if (server->opt.max_xmit > SMB_MAX_PACKET_SIZE) {
diff -puN fs/smbfs/smbiod.c~rename-struct-pid fs/smbfs/smbiod.c
--- lxc/fs/smbfs/smbiod.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/fs/smbfs/smbiod.c 2007-04-10 16:18:30.000000000 -0700
@@ -151,7 +151,7 @@ int smbiod_retry(struct smb_sb_info *ser
{
struct list_head *head;
struct smb_request *req;
- struct pid *pid = get_pid(server->conn_pid);
+ struct task_ref *tref = get_pid(server->conn_tref);
int result = 0;
VERBOSE("state: %d\n", server->state);
@@ -206,7 +206,7 @@ int smbiod_retry(struct smb_sb_info *ser
smb_close_socket(server);
- if (pid == 0) {
+ if (tref == 0) {
/* FIXME: this is fatal, umount? */
printk(KERN_ERR "smb_retry: no connection process\n");
server->state = CONN_RETRIED;
@@ -221,18 +221,18 @@ int smbiod_retry(struct smb_sb_info *ser
/*
* Note: use the "priv" flag, as a user process may need to reconnect.
*/
- result = kill_pid(pid, SIGUSR1, 1);
+ result = kill_pid(tref, SIGUSR1, 1);
if (result) {
/* FIXME: this is most likely fatal, umount? */
printk(KERN_ERR "smb_retry: signal failed [%d]\n", result);
goto out;
}
- VERBOSE("signalled pid %d\n", pid);
+ VERBOSE("signalled task reference %p\n", tref);
/* FIXME: The retried requests should perhaps get a "time boost". */
out:
- put_pid(pid);
+ put_task_ref(tref);
return result;
}
diff -puN init/main.c~rename-struct-pid init/main.c
--- lxc/init/main.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/init/main.c 2007-04-10 16:18:30.000000000 -0700
@@ -801,7 +801,7 @@ static int __init kernel_init(void * unu
init_pid_ns.child_reaper = current;
__set_special_pids(1, 1);
- cad_pid = task_pid(current);
+ cad_tref = task_pid(current);
smp_prepare_cpus(max_cpus);
diff -puN ipc/mqueue.c~rename-struct-pid ipc/mqueue.c
--- lxc/ipc/mqueue.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/ipc/mqueue.c 2007-04-10 16:18:30.000000000 -0700
@@ -73,7 +73,7 @@ struct mqueue_inode_info {
struct mq_attr attr;
struct sigevent notify;
- struct pid* notify_owner;
+ struct task_ref* notify_owner;
struct user_struct *user; /* user who created, for accounting */
struct sock *notify_sock;
struct sk_buff *notify_cookie;
@@ -338,7 +338,7 @@ static ssize_t mqueue_read_file(struct f
(info->notify_owner &&
info->notify.sigev_notify == SIGEV_SIGNAL) ?
info->notify.sigev_signo : 0,
- pid_nr(info->notify_owner));
+ tref_to_pid(info->notify_owner));
spin_unlock(&info->lock);
buffer[sizeof(buffer)-1] = '\0';
slen = strlen(buffer)+1;
@@ -528,7 +528,7 @@ static void __do_notify(struct mqueue_in
break;
}
/* after notification unregisters process */
- put_pid(info->notify_owner);
+ put_task_ref(info->notify_owner);
info->notify_owner = NULL;
}
wake_up(&info->wait_q);
@@ -572,7 +572,7 @@ static void remove_notification(struct m
set_cookie(info->notify_cookie, NOTIFY_REMOVED);
netlink_sendskb(info->notify_sock, info->notify_cookie, 0);
}
- put_pid(info->notify_owner);
+ put_task_ref(info->notify_owner);
info->notify_owner = NULL;
}
diff -puN kernel/capability.c~rename-struct-pid kernel/capability.c
--- lxc/kernel/capability.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/capability.c 2007-04-10 16:18:30.000000000 -0700
@@ -99,10 +99,10 @@ static inline int cap_set_pg(int pgrp_nr
struct task_struct *g, *target;
int ret = -EPERM;
int found = 0;
- struct pid *pgrp;
+ struct task_ref *pgrp;
- pgrp = find_pid(pgrp_nr);
- do_each_pid_task(pgrp, PIDTYPE_PGID, g) {
+ pgrp = find_task(pgrp_nr);
+ do_each_referenced_task(pgrp, REFTYPE_PGID, g) {
target = g;
while_each_thread(g, target) {
if (!security_capset_check(target, effective,
@@ -115,7 +115,7 @@ static inline int cap_set_pg(int pgrp_nr
}
found = 1;
}
- } while_each_pid_task(pgrp, PIDTYPE_PGID, g);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, g);
if (!found)
ret = 0;
diff -puN kernel/cpuset.c~rename-struct-pid kernel/cpuset.c
--- lxc/kernel/cpuset.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/cpuset.c 2007-04-10 16:18:30.000000000 -0700
@@ -2538,7 +2538,7 @@ void __cpuset_memory_pressure_bump(void)
*/
static int proc_cpuset_show(struct seq_file *m, void *v)
{
- struct pid *pid;
+ struct task_ref *tref;
struct task_struct *tsk;
char *buf;
int retval;
@@ -2549,8 +2549,8 @@ static int proc_cpuset_show(struct seq_f
goto out;
retval = -ESRCH;
- pid = m->private;
- tsk = get_pid_task(pid, PIDTYPE_PID);
+ tref = m->private;
+ tsk = get_pid_task(tref, REFTYPE_PID);
if (!tsk)
goto out_free;
@@ -2573,8 +2573,8 @@ out:
static int cpuset_open(struct inode *inode, struct file *file)
{
- struct pid *pid = PROC_I(inode)->pid;
- return single_open(file, proc_cpuset_show, pid);
+ struct task_ref *tref = PROC_I(inode)->tref;
+ return single_open(file, proc_cpuset_show, tref);
}
const struct file_operations proc_cpuset_operations = {
diff -puN kernel/exit.c~rename-struct-pid kernel/exit.c
--- lxc/kernel/exit.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/exit.c 2007-04-10 16:18:30.000000000 -0700
@@ -57,10 +57,10 @@ static void exit_mm(struct task_struct *
static void __unhash_process(struct task_struct *p)
{
nr_threads--;
- detach_pid(p, PIDTYPE_PID);
+ detach_task_ref(p, REFTYPE_PID);
if (thread_group_leader(p)) {
- detach_pid(p, PIDTYPE_PGID);
- detach_pid(p, PIDTYPE_SID);
+ detach_task_ref(p, REFTYPE_PGID);
+ detach_task_ref(p, REFTYPE_SID);
list_del_rcu(&p->tasks);
__get_cpu_var(process_counts)--;
@@ -212,14 +212,14 @@ repeat:
*
* The caller must hold rcu lock or the tasklist lock.
*/
-struct pid *session_of_pgrp(struct pid *pgrp)
+struct task_ref *session_of_pgrp(struct task_ref *pgrp)
{
struct task_struct *p;
- struct pid *sid = NULL;
+ struct task_ref *sid = NULL;
- p = pid_task(pgrp, PIDTYPE_PGID);
+ p = pid_task(pgrp, REFTYPE_PGID);
if (p == NULL)
- p = pid_task(pgrp, PIDTYPE_PID);
+ p = pid_task(pgrp, REFTYPE_PID);
if (p != NULL)
sid = task_session(p);
@@ -234,12 +234,12 @@ struct pid *session_of_pgrp(struct pid *
*
* "I ask you, have you ever known what it is to be an orphan?"
*/
-static int will_become_orphaned_pgrp(struct pid *pgrp, struct task_struct *ignored_task)
+static int will_become_orphaned_pgrp(struct task_ref *pgrp, struct task_struct *ignored_task)
{
struct task_struct *p;
int ret = 1;
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
if (p == ignored_task
|| p->exit_state
|| is_init(p->parent))
@@ -249,7 +249,7 @@ static int will_become_orphaned_pgrp(str
ret = 0;
break;
}
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
return ret; /* (sighing) "Often!" */
}
@@ -264,17 +264,17 @@ int is_current_pgrp_orphaned(void)
return retval;
}
-static int has_stopped_jobs(struct pid *pgrp)
+static int has_stopped_jobs(struct task_ref *pgrp)
{
int retval = 0;
struct task_struct *p;
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
if (p->state != TASK_STOPPED)
continue;
retval = 1;
break;
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
return retval;
}
@@ -320,14 +320,14 @@ void __set_special_pids(pid_t session, p
struct task_struct *curr = current->group_leader;
if (process_session(curr) != session) {
- detach_pid(curr, PIDTYPE_SID);
+ detach_task_ref(curr, REFTYPE_SID);
set_signal_session(curr->signal, session);
- attach_pid(curr, PIDTYPE_SID, find_pid(session));
+ attach_task_ref(curr, REFTYPE_SID, find_task(session));
}
if (process_group(curr) != pgrp) {
- detach_pid(curr, PIDTYPE_PGID);
+ detach_task_ref(curr, REFTYPE_PGID);
curr->signal->pgrp = pgrp;
- attach_pid(curr, PIDTYPE_PGID, find_pid(pgrp));
+ attach_task_ref(curr, REFTYPE_PGID, find_task(pgrp));
}
}
@@ -651,7 +651,7 @@ reparent_thread(struct task_struct *p, s
*/
if ((task_pgrp(p) != task_pgrp(father)) &&
(task_session(p) == task_session(father))) {
- struct pid *pgrp = task_pgrp(p);
+ struct task_ref *pgrp = task_pgrp(p);
if (will_become_orphaned_pgrp(pgrp, NULL) &&
has_stopped_jobs(pgrp)) {
@@ -697,7 +697,7 @@ static void exit_notify(struct task_stru
{
int state;
struct task_struct *t;
- struct pid *pgrp;
+ struct task_ref *pgrp;
int noreap;
void *cookie;
diff -puN kernel/fork.c~rename-struct-pid kernel/fork.c
--- lxc/kernel/fork.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/fork.c 2007-04-10 16:18:30.000000000 -0700
@@ -956,7 +956,7 @@ static struct task_struct *copy_process(
unsigned long stack_size,
int __user *parent_tidptr,
int __user *child_tidptr,
- struct pid *pid)
+ struct task_ref *tref)
{
int retval;
struct task_struct *p = NULL;
@@ -1023,7 +1023,7 @@ static struct task_struct *copy_process(
p->did_exec = 0;
delayacct_tsk_init(p); /* Must remain after dup_task_struct() */
copy_flags(clone_flags, p);
- p->pid = pid_nr(pid);
+ p->pid = tref_to_pid(tref);
INIT_LIST_HEAD(&p->children);
INIT_LIST_HEAD(&p->sibling);
@@ -1245,13 +1245,13 @@ static struct task_struct *copy_process(
p->signal->tty = current->signal->tty;
p->signal->pgrp = process_group(current);
set_signal_session(p->signal, process_session(current));
- attach_pid(p, PIDTYPE_PGID, task_pgrp(current));
- attach_pid(p, PIDTYPE_SID, task_session(current));
+ attach_task_ref(p, REFTYPE_PGID, task_pgrp(current));
+ attach_task_ref(p, REFTYPE_SID, task_session(current));
list_add_tail_rcu(&p->tasks, &init_task.tasks);
__get_cpu_var(process_counts)++;
}
- attach_pid(p, PIDTYPE_PID, pid);
+ attach_task_ref(p, REFTYPE_PID, tref);
nr_threads++;
}
@@ -1323,7 +1323,7 @@ struct task_struct * __cpuinit fork_idle
struct pt_regs regs;
task = copy_process(CLONE_VM, 0, idle_regs(®s), 0, NULL, NULL,
- &init_struct_pid);
+ &init_task_ref);
if (!IS_ERR(task))
init_idle(task, cpu);
@@ -1344,14 +1344,15 @@ long do_fork(unsigned long clone_flags,
int __user *child_tidptr)
{
struct task_struct *p;
- struct pid *pid = alloc_pid();
+ struct task_ref *tref = alloc_task_ref();
long nr;
- if (!pid)
+ if (!tref)
return -EAGAIN;
- nr = pid->nr;
+ nr = tref->pid;
- p = copy_process(clone_flags, stack_start, regs, stack_size, parent_tidptr, child_tidptr, pid);
+ p = copy_process(clone_flags, stack_start, regs, stack_size,
+ parent_tidptr, child_tidptr, tref);
/*
* Do this prior waking up the new thread - the thread pointer
* might get invalid after that point, if the thread exits quickly.
@@ -1393,7 +1394,7 @@ long do_fork(unsigned long clone_flags,
tracehook_report_vfork_done(p, nr);
}
} else {
- free_pid(pid);
+ free_task_ref(tref);
nr = PTR_ERR(p);
}
return nr;
diff -puN kernel/futex.c~rename-struct-pid kernel/futex.c
--- lxc/kernel/futex.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/futex.c 2007-04-10 16:18:30.000000000 -0700
@@ -2079,7 +2079,7 @@ static int futex_fd(u32 __user *uaddr, i
filp->f_mapping = filp->f_path.dentry->d_inode->i_mapping;
if (signal) {
- err = __f_setown(filp, task_pid(current), PIDTYPE_PID, 1);
+ err = __f_setown(filp, task_pid(current), REFTYPE_PID, 1);
if (err < 0) {
goto error;
}
diff -puN kernel/pid.c~rename-struct-pid kernel/pid.c
--- lxc/kernel/pid.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/pid.c 2007-04-10 16:18:30.000000000 -0700
@@ -32,8 +32,8 @@
#define pid_hashfn(nr) hash_long((unsigned long)nr, pidhash_shift)
static struct hlist_head *pid_hash;
static int pidhash_shift;
-static struct kmem_cache *pid_cachep;
-struct pid init_struct_pid = INIT_STRUCT_PID;
+static struct kmem_cache *task_ref_cachep;
+struct task_ref init_task_ref = INIT_TASK_REF;
int pid_max = PID_MAX_DEFAULT;
@@ -174,130 +174,131 @@ static int next_pidmap(struct pid_namesp
return -1;
}
-fastcall void put_pid(struct pid *pid)
+fastcall void put_task_ref(struct task_ref *tref)
{
- if (!pid)
+ if (!tref)
return;
- if ((atomic_read(&pid->count) == 1) ||
- atomic_dec_and_test(&pid->count))
- kmem_cache_free(pid_cachep, pid);
+ if ((atomic_read(&tref->count) == 1) ||
+ atomic_dec_and_test(&tref->count))
+ kmem_cache_free(task_ref_cachep, tref);
}
-EXPORT_SYMBOL_GPL(put_pid);
+EXPORT_SYMBOL_GPL(put_task_ref);
-static void delayed_put_pid(struct rcu_head *rhp)
+static void delayed_put_task_ref(struct rcu_head *rhp)
{
- struct pid *pid = container_of(rhp, struct pid, rcu);
- put_pid(pid);
+ struct task_ref *tref = container_of(rhp, struct task_ref, rcu);
+ put_task_ref(tref);
}
-fastcall void free_pid(struct pid *pid)
+fastcall void free_task_ref(struct task_ref *tref)
{
/* We can be called with write_lock_irq(&tasklist_lock) held */
unsigned long flags;
spin_lock_irqsave(&pidmap_lock, flags);
- hlist_del_rcu(&pid->pid_chain);
+ hlist_del_rcu(&tref->pid_chain);
spin_unlock_irqrestore(&pidmap_lock, flags);
- free_pidmap(&init_pid_ns, pid->nr);
- call_rcu(&pid->rcu, delayed_put_pid);
+ free_pidmap(&init_pid_ns, tref->pid);
+ call_rcu(&tref->rcu, delayed_put_task_ref);
}
-struct pid *alloc_pid(void)
+struct task_ref *alloc_task_ref(void)
{
- struct pid *pid;
- enum pid_type type;
+ struct task_ref *tref;
+ enum task_ref_type type;
int nr = -1;
- pid = kmem_cache_alloc(pid_cachep, GFP_KERNEL);
- if (!pid)
+ tref= kmem_cache_alloc(task_ref_cachep, GFP_KERNEL);
+ if (!tref)
goto out;
nr = alloc_pidmap(current->nsproxy->pid_ns);
if (nr < 0)
goto out_free;
- atomic_set(&pid->count, 1);
- pid->nr = nr;
- for (type = 0; type < PIDTYPE_MAX; ++type)
- INIT_HLIST_HEAD(&pid->tasks[type]);
+ atomic_set(&tref->count, 1);
+ tref->pid = nr;
+ for (type = 0; type < REFTYPE_MAX; ++type)
+ INIT_HLIST_HEAD(&tref->tasks[type]);
spin_lock_irq(&pidmap_lock);
- hlist_add_head_rcu(&pid->pid_chain, &pid_hash[pid_hashfn(pid->nr)]);
+ hlist_add_head_rcu(&tref->pid_chain, &pid_hash[pid_hashfn(tref->pid)]);
spin_unlock_irq(&pidmap_lock);
out:
- return pid;
+ return tref;
out_free:
- kmem_cache_free(pid_cachep, pid);
- pid = NULL;
+ kmem_cache_free(task_ref_cachep, tref);
+ tref = NULL;
goto out;
}
-struct pid * fastcall find_pid(int nr)
+struct task_ref * fastcall find_task(int nr)
{
struct hlist_node *elem;
- struct pid *pid;
+ struct task_ref *tref;
- hlist_for_each_entry_rcu(pid, elem,
+ hlist_for_each_entry_rcu(tref, elem,
&pid_hash[pid_hashfn(nr)], pid_chain) {
- if (pid->nr == nr)
- return pid;
+ if (tref->pid == nr)
+ return tref;
}
return NULL;
}
-EXPORT_SYMBOL_GPL(find_pid);
+EXPORT_SYMBOL_GPL(find_task);
/*
- * attach_pid() must be called with the tasklist_lock write-held.
+ * attach_task_ref() must be called with the tasklist_lock write-held.
*/
-int fastcall attach_pid(struct task_struct *task, enum pid_type type,
- struct pid *pid)
+int fastcall attach_task_ref(struct task_struct *task, enum task_ref_type type,
+ struct task_ref *tref)
{
struct pid_link *link;
link = &task->pids[type];
- link->pid = pid;
- hlist_add_head_rcu(&link->node, &pid->tasks[type]);
+ link->tref = tref;
+ hlist_add_head_rcu(&link->node, &tref->tasks[type]);
return 0;
}
-void fastcall detach_pid(struct task_struct *task, enum pid_type type)
+void fastcall detach_task_ref(struct task_struct *task, enum task_ref_type type)
{
struct pid_link *link;
- struct pid *pid;
+ struct task_ref *tref;
int tmp;
link = &task->pids[type];
- pid = link->pid;
+ tref = link->tref;
hlist_del_rcu(&link->node);
- link->pid = NULL;
+ link->tref = NULL;
- for (tmp = PIDTYPE_MAX; --tmp >= 0; )
- if (!hlist_empty(&pid->tasks[tmp]))
+ for (tmp = REFTYPE_MAX; --tmp >= 0; )
+ if (!hlist_empty(&tref->tasks[tmp]))
return;
- free_pid(pid);
+ free_task_ref(tref);
}
-/* transfer_pid is an optimization of attach_pid(new), detach_pid(old) */
-void fastcall transfer_pid(struct task_struct *old, struct task_struct *new,
- enum pid_type type)
+/* transfer_task_ref is an optimization of attach_pid(new), detach_pid(old) */
+void fastcall transfer_task_ref(struct task_struct *old,
+ struct task_struct *new,
+ enum task_ref_type type)
{
- new->pids[type].pid = old->pids[type].pid;
+ new->pids[type].tref = old->pids[type].tref;
hlist_replace_rcu(&old->pids[type].node, &new->pids[type].node);
- old->pids[type].pid = NULL;
+ old->pids[type].tref = NULL;
}
-struct task_struct * fastcall pid_task(struct pid *pid, enum pid_type type)
+struct task_struct * fastcall pid_task(struct task_ref *tref, enum task_ref_type type)
{
struct task_struct *result = NULL;
- if (pid) {
+ if (tref) {
struct hlist_node *first;
- first = rcu_dereference(pid->tasks[type].first);
+ first = rcu_dereference(tref->tasks[type].first);
if (first)
result = hlist_entry(first, struct task_struct, pids[(type)].node);
}
@@ -307,61 +308,61 @@ struct task_struct * fastcall pid_task(s
/*
* Must be called under rcu_read_lock() or with tasklist_lock read-held.
*/
-struct task_struct *find_task_by_pid_type(int type, int nr)
+struct task_struct *find_task_by_ref_type(int type, int nr)
{
- return pid_task(find_pid(nr), type);
+ return pid_task(find_task(nr), type);
}
-EXPORT_SYMBOL(find_task_by_pid_type);
+EXPORT_SYMBOL(find_task_by_ref_type);
-struct pid *get_task_pid(struct task_struct *task, enum pid_type type)
+struct task_ref *get_task_ref(struct task_struct *task, enum task_ref_type type)
{
- struct pid *pid;
+ struct task_ref *tref;
rcu_read_lock();
- pid = get_pid(task->pids[type].pid);
+ tref = get_pid(task->pids[type].tref);
rcu_read_unlock();
- return pid;
+ return tref;
}
-struct task_struct *fastcall get_pid_task(struct pid *pid, enum pid_type type)
+struct task_struct *fastcall get_pid_task(struct task_ref *tref, enum task_ref_type type)
{
struct task_struct *result;
rcu_read_lock();
- result = pid_task(pid, type);
+ result = pid_task(tref, type);
if (result)
get_task_struct(result);
rcu_read_unlock();
return result;
}
-struct pid *find_get_pid(pid_t nr)
+struct task_ref *find_get_pid(pid_t nr)
{
- struct pid *pid;
+ struct task_ref *tref;
rcu_read_lock();
- pid = get_pid(find_pid(nr));
+ tref = get_pid(find_task(nr));
rcu_read_unlock();
- return pid;
+ return tref;
}
/*
* Used by proc to find the first pid that is greater then or equal to nr.
*
- * If there is a pid at nr this function is exactly the same as find_pid.
+ * If there is a pid at nr this function is exactly the same as find_task.
*/
-struct pid *find_ge_pid(int nr)
+struct task_ref *find_ge_pid(int nr)
{
- struct pid *pid;
+ struct task_ref *tref;
do {
- pid = find_pid(nr);
- if (pid)
+ tref = find_task(nr);
+ if (tref)
break;
nr = next_pidmap(current->nsproxy->pid_ns, nr);
} while (nr > 0);
- return pid;
+ return tref;
}
EXPORT_SYMBOL_GPL(find_get_pid);
@@ -412,7 +413,8 @@ void __init pidmap_init(void)
set_bit(0, init_pid_ns.pidmap[0].page);
atomic_dec(&init_pid_ns.pidmap[0].nr_free);
- pid_cachep = kmem_cache_create("pid", sizeof(struct pid),
- __alignof__(struct pid),
+ task_ref_cachep = kmem_cache_create("task_ref",
+ sizeof(struct task_ref),
+ __alignof__(struct task_ref),
SLAB_PANIC, NULL, NULL);
}
diff -puN kernel/rtmutex-debug.c~rename-struct-pid kernel/rtmutex-debug.c
--- lxc/kernel/rtmutex-debug.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/rtmutex-debug.c 2007-04-10 16:18:30.000000000 -0700
@@ -238,4 +238,3 @@ rt_mutex_deadlock_account_lock(struct rt
void rt_mutex_deadlock_account_unlock(struct task_struct *task)
{
}
-
diff -puN kernel/signal.c~rename-struct-pid kernel/signal.c
--- lxc/kernel/signal.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/signal.c 2007-04-10 16:18:30.000000000 -0700
@@ -1224,22 +1224,22 @@ int group_send_sig_info(int sig, struct
* control characters do (^C, ^Z etc)
*/
-int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
+int __kill_pgrp_info(int sig, struct siginfo *info, struct task_ref *pgrp)
{
struct task_struct *p = NULL;
int retval, success;
success = 0;
retval = -ESRCH;
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
int err = group_send_sig_info(sig, info, p);
success |= !err;
retval = err;
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
return success ? 0 : retval;
}
-int kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp)
+int kill_pgrp_info(int sig, struct siginfo *info, struct task_ref *pgrp)
{
int retval;
@@ -1250,7 +1250,7 @@ int kill_pgrp_info(int sig, struct sigin
return retval;
}
-int kill_pid_info(int sig, struct siginfo *info, struct pid *pid)
+int kill_pid_info(int sig, struct siginfo *info, struct task_ref *pid)
{
int error;
struct task_struct *p;
@@ -1259,7 +1259,7 @@ int kill_pid_info(int sig, struct siginf
if (unlikely(sig_needs_tasklist(sig)))
read_lock(&tasklist_lock);
- p = pid_task(pid, PIDTYPE_PID);
+ p = pid_task(pid, REFTYPE_PID);
error = -ESRCH;
if (p)
error = group_send_sig_info(sig, info, p);
@@ -1275,13 +1275,13 @@ kill_proc_info(int sig, struct siginfo *
{
int error;
rcu_read_lock();
- error = kill_pid_info(sig, info, find_pid(pid));
+ error = kill_pid_info(sig, info, find_task(pid));
rcu_read_unlock();
return error;
}
/* like kill_pid_info(), but doesn't use uid/euid of "current" */
-int kill_pid_info_as_uid(int sig, struct siginfo *info, struct pid *pid,
+int kill_pid_info_as_uid(int sig, struct siginfo *info, struct task_ref *pid,
uid_t uid, uid_t euid, u32 secid)
{
int ret = -EINVAL;
@@ -1291,7 +1291,7 @@ int kill_pid_info_as_uid(int sig, struct
return ret;
read_lock(&tasklist_lock);
- p = pid_task(pid, PIDTYPE_PID);
+ p = pid_task(pid, REFTYPE_PID);
if (!p) {
ret = -ESRCH;
goto out_unlock;
@@ -1346,9 +1346,9 @@ static int kill_something_info(int sig,
read_unlock(&tasklist_lock);
ret = count ? retval : -ESRCH;
} else if (pid < 0) {
- ret = kill_pgrp_info(sig, info, find_pid(-pid));
+ ret = kill_pgrp_info(sig, info, find_task(-pid));
} else {
- ret = kill_pid_info(sig, info, find_pid(pid));
+ ret = kill_pid_info(sig, info, find_task(pid));
}
rcu_read_unlock();
return ret;
@@ -1437,13 +1437,13 @@ force_sigsegv(int sig, struct task_struc
return 0;
}
-int kill_pgrp(struct pid *pid, int sig, int priv)
+int kill_pgrp(struct task_ref *pid, int sig, int priv)
{
return kill_pgrp_info(sig, __si_special(priv), pid);
}
EXPORT_SYMBOL(kill_pgrp);
-int kill_pid(struct pid *pid, int sig, int priv)
+int kill_pid(struct task_ref *pid, int sig, int priv)
{
return kill_pid_info(sig, __si_special(priv), pid);
}
diff -puN kernel/sys.c~rename-struct-pid kernel/sys.c
--- lxc/kernel/sys.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/sys.c 2007-04-10 16:18:30.000000000 -0700
@@ -93,8 +93,8 @@ EXPORT_SYMBOL(fs_overflowgid);
*/
int C_A_D = 1;
-struct pid *cad_pid;
-EXPORT_SYMBOL(cad_pid);
+struct task_ref *cad_tref;
+EXPORT_SYMBOL(cad_tref);
/*
* Notifier list for kernel code which wants to be called
@@ -657,7 +657,7 @@ asmlinkage long sys_setpriority(int whic
struct task_struct *g, *p;
struct user_struct *user;
int error = -EINVAL;
- struct pid *pgrp;
+ struct task_ref *pgrp;
if (which > 2 || which < 0)
goto out;
@@ -681,12 +681,12 @@ asmlinkage long sys_setpriority(int whic
break;
case PRIO_PGRP:
if (who)
- pgrp = find_pid(who);
+ pgrp = find_task(who);
else
pgrp = task_pgrp(current);
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
error = set_one_prio(p, niceval, error);
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
break;
case PRIO_USER:
user = current->user;
@@ -721,7 +721,7 @@ asmlinkage long sys_getpriority(int whic
struct task_struct *g, *p;
struct user_struct *user;
long niceval, retval = -ESRCH;
- struct pid *pgrp;
+ struct task_ref *pgrp;
if (which > 2 || which < 0)
return -EINVAL;
@@ -741,14 +741,14 @@ asmlinkage long sys_getpriority(int whic
break;
case PRIO_PGRP:
if (who)
- pgrp = find_pid(who);
+ pgrp = find_task(who);
else
pgrp = task_pgrp(current);
- do_each_pid_task(pgrp, PIDTYPE_PGID, p) {
+ do_each_referenced_task(pgrp, REFTYPE_PGID, p) {
niceval = 20 - task_nice(p);
if (niceval > retval)
retval = niceval;
- } while_each_pid_task(pgrp, PIDTYPE_PGID, p);
+ } while_each_referenced_task(pgrp, REFTYPE_PGID, p);
break;
case PRIO_USER:
user = current->user;
@@ -1474,7 +1474,7 @@ asmlinkage long sys_setpgid(pid_t pid, p
if (pgid != pid) {
struct task_struct *g =
- find_task_by_pid_type(PIDTYPE_PGID, pgid);
+ find_task_by_ref_type(REFTYPE_PGID, pgid);
if (!g || task_session(g) != task_session(group_leader))
goto out;
@@ -1485,9 +1485,9 @@ asmlinkage long sys_setpgid(pid_t pid, p
goto out;
if (process_group(p) != pgid) {
- detach_pid(p, PIDTYPE_PGID);
+ detach_task_ref(p, REFTYPE_PGID);
p->signal->pgrp = pgid;
- attach_pid(p, PIDTYPE_PGID, find_pid(pgid));
+ attach_task_ref(p, REFTYPE_PGID, find_task(pgid));
}
err = 0;
@@ -1571,7 +1571,7 @@ asmlinkage long sys_setsid(void)
* session id and so the check will always fail and make it so
* init cannot successfully call setsid.
*/
- if (session > 1 && find_task_by_pid_type(PIDTYPE_PGID, session))
+ if (session > 1 && find_task_by_ref_type(REFTYPE_PGID, session))
goto out;
group_leader->signal->leader = 1;
diff -puN kernel/sysctl.c~rename-struct-pid kernel/sysctl.c
--- lxc/kernel/sysctl.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/kernel/sysctl.c 2007-04-10 16:18:30.000000000 -0700
@@ -2127,22 +2127,22 @@ int proc_dointvec_ms_jiffies(ctl_table *
static int proc_do_cad_pid(ctl_table *table, int write, struct file *filp,
void __user *buffer, size_t *lenp, loff_t *ppos)
{
- struct pid *new_pid;
+ struct task_ref *new_tref;
pid_t tmp;
int r;
- tmp = pid_nr(cad_pid);
+ tmp = tref_to_pid(cad_tref);
r = __do_proc_dointvec(&tmp, table, write, filp, buffer,
lenp, ppos, NULL, NULL);
if (r || !write)
return r;
- new_pid = find_get_pid(tmp);
- if (!new_pid)
+ new_tref = find_get_pid(tmp);
+ if (!new_tref)
return -ESRCH;
- put_pid(xchg(&cad_pid, new_pid));
+ put_task_ref(xchg(&cad_tref, new_tref));
return 0;
}
diff -puN mm/mempolicy.c~rename-struct-pid mm/mempolicy.c
--- lxc/mm/mempolicy.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/mm/mempolicy.c 2007-04-10 16:18:30.000000000 -0700
@@ -923,7 +923,7 @@ asmlinkage long sys_migrate_pages(pid_t
/* Find the mm_struct */
read_lock(&tasklist_lock);
- task = pid ? find_task_by_pid(pid) : current;
+ task = pid ? find_task_by_ref(pid) : current;
if (!task) {
read_unlock(&tasklist_lock);
return -ESRCH;
@@ -1909,4 +1909,3 @@ out:
m->version = (vma != priv->tail_vma) ? vma->vm_start : 0;
return 0;
}
-
diff -puN mm/migrate.c~rename-struct-pid mm/migrate.c
--- lxc/mm/migrate.c~rename-struct-pid 2007-04-10 16:18:30.000000000 -0700
+++ lxc-dave/mm/migrate.c 2007-04-10 16:18:30.000000000 -0700
@@ -887,7 +887,7 @@ asmlinkage long sys_move_pages(pid_t pid
/* Find the mm_struct */
read_lock(&tasklist_lock);
- task = pid ? find_task_by_pid(pid) : current;
+ task = pid ? find_task_by_ref(pid) : current;
if (!task) {
read_unlock(&tasklist_lock);
return -ESRCH;
_
_______________________________________________
Containers mailing list
Containers@lists.linux-foundation.org
https://lists.linux-foundation.org/mailman/listinfo/containers
OpenVZ Forum
Members
Search
Help
Register
Login
Home
