X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=kernel%2Fvserver%2Fcontext.c;h=c897a8697c77658fc89baa8b145a58c9bc0ced3d;hb=c7b5ebbddf7bcd3651947760f423e3783bbe6573;hp=533e104396b0d4c035f38d7a5eb9a5b94ea76339;hpb=9213980e6a70d8473e0ffd4b39ab5b6caaba9ff5;p=linux-2.6.git

diff --git a/kernel/vserver/context.c b/kernel/vserver/context.c
index 533e10439..c897a8697 100644
--- a/kernel/vserver/context.c
+++ b/kernel/vserver/context.c
@@ -37,8 +37,8 @@
 static struct vx_info *__alloc_vx_info(xid_t xid)
 {
 	struct vx_info *new = NULL;
-	
-	vxdprintk("alloc_vx_info(%d)\n", xid);
+
+	vxdprintk(VXD_CBIT(xid, 0), "alloc_vx_info(%d)*", xid);
 
 	/* would this benefit from a slab cache? */
 	new = kmalloc(sizeof(struct vx_info), GFP_KERNEL);
@@ -51,6 +51,10 @@ static struct vx_info *__alloc_vx_info(xid_t xid)
 	INIT_HLIST_NODE(&new->vx_hlist);
 	atomic_set(&new->vx_refcnt, 0);
 	atomic_set(&new->vx_usecnt, 0);
+	new->vx_parent = NULL;
+	new->vx_state = 0;
+	new->vx_lock = SPIN_LOCK_UNLOCKED;
+	init_waitqueue_head(&new->vx_exit);
 
 	/* rest of init goes here */
 	vx_info_init_limit(&new->limit);
@@ -58,11 +62,13 @@ static struct vx_info *__alloc_vx_info(xid_t xid)
 	vx_info_init_cvirt(&new->cvirt);
 	vx_info_init_cacct(&new->cacct);
 
+
 	new->vx_flags = VXF_STATE_SETUP|VXF_STATE_INIT;
 	new->vx_bcaps = CAP_INIT_EFF_SET;
 	new->vx_ccaps = 0;
 
-	vxdprintk("alloc_vx_info(%d) = %p\n", xid, new);
+	vxdprintk(VXD_CBIT(xid, 0),
+		"alloc_vx_info(%d) = %p", xid, new);
 	return new;
 }
 
@@ -72,31 +78,85 @@ static struct vx_info *__alloc_vx_info(xid_t xid)
 
 static void __dealloc_vx_info(struct vx_info *vxi)
 {
-	vxdprintk("dealloc_vx_info(%p)\n", vxi);
+	vxdprintk(VXD_CBIT(xid, 0),
+		"dealloc_vx_info(%p)", vxi);
 
 	vxi->vx_hlist.next = LIST_POISON1;
 	vxi->vx_id = -1;
 
-	if (vxi->vx_namespace)
-		put_namespace(vxi->vx_namespace);
-	if (vxi->vx_fs)
-		put_fs_struct(vxi->vx_fs);
-	
 	vx_info_exit_limit(&vxi->limit);
 	vx_info_exit_sched(&vxi->sched);
 	vx_info_exit_cvirt(&vxi->cvirt);
 	vx_info_exit_cacct(&vxi->cacct);
-	
+
+
 	BUG_ON(atomic_read(&vxi->vx_usecnt));
 	BUG_ON(atomic_read(&vxi->vx_refcnt));
 
+	BUG_ON(vx_info_state(vxi, VXS_HASHED));
+	// BUG_ON(!vx_state(vxi, VXS_DEFUNCT));
+
+	vxi->vx_state |= VXS_RELEASED;
 	kfree(vxi);
 }
 
+static inline int __free_vx_info(struct vx_info *vxi)
+{
+	int usecnt, refcnt;
+
+	BUG_ON(!vxi);
+
+	usecnt = atomic_read(&vxi->vx_usecnt);
+	BUG_ON(usecnt < 0);
+
+	refcnt = atomic_read(&vxi->vx_refcnt);
+	BUG_ON(refcnt < 0);
+
+	if (!usecnt)
+		__dealloc_vx_info(vxi);
+	return usecnt;
+}
+
+#if 0
+
+static void __rcu_free_vx_info(struct rcu_head *head)
+{
+	struct vx_info *vxi = container_of(head, struct vx_info, vx_rcu);
+
+	BUG_ON(!head);
+	vxdprintk(VXD_CBIT(xid, 3),
+		"rcu_free_vx_info(%p): uc=%d", vxi,
+		atomic_read(&vxi->vx_usecnt));
+
+	__free_vx_info(vxi);
+}
+
+#endif
+
+void free_vx_info(struct vx_info *vxi)
+{
+	struct namespace *namespace;
+	struct fs_struct *fs;
+
+	/* context shutdown is mandatory */
+	// BUG_ON(vxi->vx_state != VXS_SHUTDOWN);
+
+	namespace = xchg(&vxi->vx_namespace, NULL);
+	fs = xchg(&vxi->vx_fs, NULL);
+
+	if (namespace)
+		put_namespace(namespace);
+	if (fs)
+		put_fs_struct(fs);
+
+	BUG_ON(__free_vx_info(vxi));
+	// call_rcu(&i->vx_rcu, __rcu_free_vx_info);
+}
+
 
 /*	hash table for vx_info hash */
 
-#define	VX_HASH_SIZE	13
+#define VX_HASH_SIZE	13
 
 struct hlist_head vx_info_hash[VX_HASH_SIZE];
 
@@ -118,9 +178,11 @@ static inline unsigned int __hashval(xid_t xid)
 static inline void __hash_vx_info(struct vx_info *vxi)
 {
 	struct hlist_head *head;
-	
-	vxdprintk("__hash_vx_info: %p[#%d]\n", vxi, vxi->vx_id);
+
+	vxdprintk(VXD_CBIT(xid, 4),
+		"__hash_vx_info: %p[#%d]", vxi, vxi->vx_id);
 	get_vx_info(vxi);
+	vxi->vx_state |= VXS_HASHED;
 	head = &vx_info_hash[__hashval(vxi->vx_id)];
 	hlist_add_head_rcu(&vxi->vx_hlist, head);
 }
@@ -132,7 +194,9 @@ static inline void __hash_vx_info(struct vx_info *vxi)
 
 static inline void __unhash_vx_info(struct vx_info *vxi)
 {
-	vxdprintk("__unhash_vx_info: %p[#%d]\n", vxi, vxi->vx_id);
+	vxdprintk(VXD_CBIT(xid, 4),
+		"__unhash_vx_info: %p[#%d]", vxi, vxi->vx_id);
+	vxi->vx_state &= ~VXS_HASHED;
 	hlist_del_rcu(&vxi->vx_hlist);
 	put_vx_info(vxi);
 }
@@ -152,9 +216,9 @@ static inline struct vx_info *__lookup_vx_info(xid_t xid)
 		struct vx_info *vxi =
 			hlist_entry(pos, struct vx_info, vx_hlist);
 
-		if (vxi->vx_id == xid) {
+		if ((vxi->vx_id == xid) &&
+			vx_info_state(vxi, VXS_HASHED))
 			return vxi;
-		}
 	}
 	return NULL;
 }
@@ -169,12 +233,15 @@ static inline xid_t __vx_dynamic_id(void)
 {
 	static xid_t seq = MAX_S_CONTEXT;
 	xid_t barrier = seq;
-	
+
 	do {
 		if (++seq > MAX_S_CONTEXT)
 			seq = MIN_D_CONTEXT;
-		if (!__lookup_vx_info(seq))
+		if (!__lookup_vx_info(seq)) {
+			vxdprintk(VXD_CBIT(xid, 4),
+				"__vx_dynamic_id: [#%d]", seq);
 			return seq;
+		}
 	} while (barrier != seq);
 	return 0;
 }
@@ -187,8 +254,8 @@ static inline xid_t __vx_dynamic_id(void)
 static struct vx_info * __loc_vx_info(int id, int *err)
 {
 	struct vx_info *new, *vxi = NULL;
-	
-	vxdprintk("loc_vx_info(%d)\n", id);
+
+	vxdprintk(VXD_CBIT(xid, 1), "loc_vx_info(%d)*", id);
 
 	if (!(new = __alloc_vx_info(id))) {
 		*err = -ENOMEM;
@@ -210,11 +277,13 @@ static struct vx_info * __loc_vx_info(int id, int *err)
 	else if ((vxi = __lookup_vx_info(id))) {
 		/* context in setup is not available */
 		if (vxi->vx_flags & VXF_STATE_SETUP) {
-			vxdprintk("loc_vx_info(%d) = %p (not available)\n", id, vxi);
+			vxdprintk(VXD_CBIT(xid, 0),
+				"loc_vx_info(%d) = %p (not available)", id, vxi);
 			vxi = NULL;
 			*err = -EBUSY;
 		} else {
-			vxdprintk("loc_vx_info(%d) = %p (found)\n", id, vxi);
+			vxdprintk(VXD_CBIT(xid, 0),
+				"loc_vx_info(%d) = %p (found)", id, vxi);
 			get_vx_info(vxi);
 			*err = 0;
 		}
@@ -222,7 +291,8 @@ static struct vx_info * __loc_vx_info(int id, int *err)
 	}
 
 	/* new context requested */
-	vxdprintk("loc_vx_info(%d) = %p (new)\n", id, new);
+	vxdprintk(VXD_CBIT(xid, 0),
+		"loc_vx_info(%d) = %p (new)", id, new);
 	__hash_vx_info(get_vx_info(new));
 	vxi = new, new = NULL;
 	*err = 1;
@@ -239,26 +309,6 @@ out_unlock:
 /*	exported stuff						*/
 
 
-
-void rcu_free_vx_info(void *obj)
-{
-	struct vx_info *vxi = obj;
-	int usecnt, refcnt;
-
-	BUG_ON(!vxi);
-
-	usecnt = atomic_read(&vxi->vx_usecnt);
-	BUG_ON(usecnt < 0);
-
-	refcnt = atomic_read(&vxi->vx_refcnt);
-	BUG_ON(refcnt < 0);
-
-	if (!usecnt)
-		__dealloc_vx_info(vxi);
-	else
-		printk("!!! rcu didn't free\n");
-}
-
 void unhash_vx_info(struct vx_info *vxi)
 {
 	spin_lock(&vx_info_hash_lock);
@@ -268,13 +318,13 @@ void unhash_vx_info(struct vx_info *vxi)
 
 /*	locate_vx_info()
 
-	* search for a vx_info and get() it			
+	* search for a vx_info and get() it
 	* negative id means current				*/
 
 struct vx_info *locate_vx_info(int id)
 {
 	struct vx_info *vxi;
-	
+
 	if (id < 0) {
 		vxi = get_vx_info(current->vx_info);
 	} else {
@@ -319,10 +369,6 @@ struct vx_info *locate_or_create_vx_info(int id)
 
 #ifdef	CONFIG_PROC_FS
 
-#define hlist_for_each_rcu(pos, head) \
-        for (pos = (head)->first; pos && ({ prefetch(pos->next); 1;}); \
-		pos = pos->next, ({ smp_read_barrier_depends(); 0;}))
-
 int get_xid_list(int index, unsigned int *xids, int size)
 {
 	int hindex, nr_xids = 0;
@@ -339,7 +385,7 @@ int get_xid_list(int index, unsigned int *xids, int size)
 				continue;
 
 			vxi = hlist_entry(pos, struct vx_info, vx_hlist);
-			xids[nr_xids] = vxi->vx_id;			
+			xids[nr_xids] = vxi->vx_id;
 			if (++nr_xids >= size)
 				goto out;
 		}
@@ -353,7 +399,7 @@ out:
 int vx_migrate_user(struct task_struct *p, struct vx_info *vxi)
 {
 	struct user_struct *new_user, *old_user;
-	
+
 	if (!p || !vxi)
 		BUG();
 	new_user = alloc_uid(vxi->vx_id, p->uid);
@@ -385,25 +431,23 @@ void vx_mask_bcaps(struct task_struct *p)
 static inline int vx_nofiles_task(struct task_struct *tsk)
 {
 	struct files_struct *files = tsk->files;
-	const unsigned long *obptr, *cbptr;
+	unsigned long *obptr;
 	int count, total;
 
 	spin_lock(&files->file_lock);
 	obptr = files->open_fds->fds_bits;
-	cbptr = files->close_on_exec->fds_bits;
 	count = files->max_fds / (sizeof(unsigned long) * 8);
 	for (total = 0; count > 0; count--) {
 		if (*obptr)
 			total += hweight_long(*obptr);
 		obptr++;
-	/*	if (*cbptr)
-			total += hweight_long(*cbptr);
-		cbptr++; */
 	}
 	spin_unlock(&files->file_lock);
 	return total;
 }
 
+#if 0
+
 static inline int vx_openfd_task(struct task_struct *tsk)
 {
 	struct files_struct *files = tsk->files;
@@ -422,6 +466,8 @@ static inline int vx_openfd_task(struct task_struct *tsk)
 	return total;
 }
 
+#endif
+
 /*
  *	migrate task to new context
  *	gets vxi, puts old_vxi on change
@@ -431,7 +477,7 @@ int vx_migrate_task(struct task_struct *p, struct vx_info *vxi)
 {
 	struct vx_info *old_vxi;
 	int ret = 0;
-	
+
 	if (!p || !vxi)
 		BUG();
 
@@ -439,26 +485,36 @@ int vx_migrate_task(struct task_struct *p, struct vx_info *vxi)
 	if (old_vxi == vxi)
 		goto out;
 
-	vxdprintk("vx_migrate_task(%p,%p[#%d.%d)\n", p, vxi,
+	vxdprintk(VXD_CBIT(xid, 5),
+		"vx_migrate_task(%p,%p[#%d.%d])", p, vxi,
 		vxi->vx_id, atomic_read(&vxi->vx_usecnt));
 
 	if (!(ret = vx_migrate_user(p, vxi))) {
-		int openfd, nofiles;
+		int nofiles;
 
 		task_lock(p);
-		openfd = vx_openfd_task(p);
+		// openfd = vx_openfd_task(p);
 		nofiles = vx_nofiles_task(p);
 
 		if (old_vxi) {
-			atomic_dec(&old_vxi->cacct.nr_threads);
+			atomic_dec(&old_vxi->cvirt.nr_threads);
+			atomic_dec(&old_vxi->cvirt.nr_running);
 			atomic_dec(&old_vxi->limit.rcur[RLIMIT_NPROC]);
-			atomic_sub(nofiles, &vxi->limit.rcur[RLIMIT_NOFILE]);
-			atomic_sub(openfd, &vxi->limit.rcur[RLIMIT_OPENFD]);
-		}		
-		atomic_inc(&vxi->cacct.nr_threads);
+			/* FIXME: what about the struct files here? */
+			// atomic_sub(nofiles, &old_vxi->limit.rcur[RLIMIT_NOFILE]);
+			// atomic_sub(openfd, &old_vxi->limit.rcur[RLIMIT_OPENFD]);
+		}
+		atomic_inc(&vxi->cvirt.nr_threads);
+		atomic_inc(&vxi->cvirt.nr_running);
 		atomic_inc(&vxi->limit.rcur[RLIMIT_NPROC]);
-		atomic_add(nofiles, &vxi->limit.rcur[RLIMIT_NOFILE]);
-		atomic_add(openfd, &vxi->limit.rcur[RLIMIT_OPENFD]);
+		/* FIXME: what about the struct files here? */
+		// atomic_add(nofiles, &vxi->limit.rcur[RLIMIT_NOFILE]);
+		// atomic_add(openfd, &vxi->limit.rcur[RLIMIT_OPENFD]);
+
+		vxdprintk(VXD_CBIT(xid, 5),
+			"moved task %p into vxi:%p[#%d]",
+			p, vxi, vxi->vx_id);
+
 		/* should be handled in set_vx_info !! */
 		if (old_vxi)
 			clr_vx_info(&p->vx_info);
@@ -479,10 +535,14 @@ int vx_set_init(struct vx_info *vxi, struct task_struct *p)
 {
 	if (!vxi)
 		return -EINVAL;
-        if (vxi->vx_initpid)
-                return -EPERM;
+	if (vxi->vx_initpid)
+		return -EPERM;
+
+	vxdprintk(VXD_CBIT(xid, 6),
+		"vx_set_init(%p[#%d],%p[#%d,%d,%d])",
+		vxi, vxi->vx_id, p, p->xid, p->pid, p->tgid);
 
-        vxi->vx_initpid = p->tgid;
+	vxi->vx_initpid = p->tgid;
 	return 0;
 }
 
@@ -496,22 +556,22 @@ int vx_set_init(struct vx_info *vxi, struct task_struct *p)
 
 int vc_task_xid(uint32_t id, void __user *data)
 {
-        xid_t xid;
-
-        if (id) {
-                struct task_struct *tsk;
-
-                if (!vx_check(0, VX_ADMIN|VX_WATCH))
-                        return -EPERM;
-
-                read_lock(&tasklist_lock);
-                tsk = find_task_by_pid(id);
-                xid = (tsk) ? tsk->xid : -ESRCH;
-                read_unlock(&tasklist_lock);
-        }
-        else
-                xid = current->xid;
-        return xid;
+	xid_t xid;
+
+	if (id) {
+		struct task_struct *tsk;
+
+		if (!vx_check(0, VX_ADMIN|VX_WATCH))
+			return -EPERM;
+
+		read_lock(&tasklist_lock);
+		tsk = find_task_by_real_pid(id);
+		xid = (tsk) ? tsk->xid : -ESRCH;
+		read_unlock(&tasklist_lock);
+	}
+	else
+		xid = current->xid;
+	return xid;
 }
 
 
@@ -575,7 +635,7 @@ out_put:
 int vc_ctx_migrate(uint32_t id, void __user *data)
 {
 	struct vx_info *vxi;
-	
+
 	if (!capable(CAP_SYS_ADMIN))
 		return -EPERM;
 
@@ -694,7 +754,8 @@ int vc_set_ccaps(uint32_t id, void __user *data)
 
 #include <linux/module.h>
 
-EXPORT_SYMBOL_GPL(rcu_free_vx_info);
+// EXPORT_SYMBOL_GPL(rcu_free_vx_info);
+EXPORT_SYMBOL_GPL(free_vx_info);
 EXPORT_SYMBOL_GPL(vx_info_hash_lock);
 EXPORT_SYMBOL_GPL(unhash_vx_info);