multiple namespaces

diff -Naurd old/fs/namespace.c new/fs/namespace.c
@@ -32,6 +32,122 @@
 static int hash_mask, hash_bits;
 static kmem_cache_t *mnt_cache; 
 
+static struct fs_struct *drive_array[128];
+spinlock_t drive_array_lock __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
+
+#if 0
+void shutdown_drive_array(void)
+{
+	int i == sizeof(drive_array)/sizeof(drive_array[0]);
+	spin_lock(&drive_array_lock);
+		while (i--) {
+			if (drive_array[i]) {
+				put_fs_struct(drive_array[i]);
+				drive_array[i] = NULL;
+			}
+		}
+	spin_unlock(&drive_array_lock);
+}
+#endif
+
+long set_current_drive(int drive)
+{
+	struct fs_struct *src;
+	struct fs_struct *dst;
+	int ret = -EINVAL;
+	if (drive=='C' || drive<'A' || drive>'z')
+		return -EINVAL;
+	spin_lock(&drive_array_lock);
+	dst = current->fs;
+	src = drive_array[drive];
+	write_lock(&dst->lock);
+
+	if (src || drive=='C') {
+		if (dst->currentdrive == 'C') {
+			dst->c_rootmnt    = dst->rootmnt;
+			dst->c_root       = dst->root;
+			dst->c_pwdmnt     = dst->pwdmnt;
+			dst->c_pwd        = dst->pwd;
+			dst->c_altrootmnt = dst->altrootmnt;
+			dst->c_altroot    = dst->altroot;
+		} else {
+			dput(dst->root);
+			mntput(dst->rootmnt);
+			dput(dst->pwd);
+			mntput(dst->pwdmnt);
+			if (dst->altroot) {
+				dput(dst->altroot);
+				mntput(dst->altrootmnt);
+			}
+		}
+
+		ret = 0;
+		dst->currentdrive = drive;
+
+		if (drive=='C') {
+			dst->rootmnt    = dst->c_rootmnt;
+			dst->root       = dst->c_root;
+			dst->pwdmnt     = dst->c_pwdmnt;
+			dst->pwd        = dst->c_pwd;
+			dst->altrootmnt = dst->c_altrootmnt;
+			dst->altroot    = dst->c_altroot;
+		} else {
+			dst->rootmnt = mntget(src->rootmnt);
+			dst->root    = dget(src->root);
+			dst->pwdmnt  = mntget(src->pwdmnt);
+			dst->pwd     = dget(src->pwd);
+			if (src->altroot) {
+				dst->altrootmnt = mntget(src->altrootmnt);
+				dst->altroot    = dget(src->altroot);
+			} else {
+				dst->altrootmnt = NULL;
+				dst->altroot    = NULL;
+			}
+		}
+
+	}
+
+	write_unlock(&dst->lock);
+	spin_unlock(&drive_array_lock);
+	return ret;
+}
+
+long subst_drive_create(int drive)
+{
+	struct fs_struct *fs;
+	printk("sizeof(drive_array) is %u\n", (unsigned)sizeof(drive_array));
+	printk("asked for drive '%c' 0x%02u %d\n", (char)drive, (unsigned)drive, drive);
+	if (drive=='C' || drive<'A' || drive>'z')
+		return -EINVAL;
+	spin_lock(&drive_array_lock);
+	fs = drive_array[drive];
+	drive_array[drive] = copy_fs_struct(current->fs);
+	printk("fs is %u\n", (unsigned)fs);
+	if (fs)
+		put_fs_struct(fs);
+	printk("debug 1\n");
+	spin_unlock(&drive_array_lock);
+	printk("debug 1\n");
+	return 0;
+}
+
+long subst_drive_destroy(int drive)
+{
+	struct fs_struct *fs;
+	int ret = -EINVAL;
+	if (drive=='C' || drive<'A' || drive>'z')
+		return -EINVAL;
+	spin_lock(&drive_array_lock);
+	fs = drive_array[drive];
+	if (fs) {
+		ret = 0;
+		drive_array[drive] = NULL;
+		put_fs_struct(fs);
+	}
+	spin_unlock(&drive_array_lock);
+	return ret;
+}
+
 static inline unsigned long hash(struct vfsmount *mnt, struct dentry *dentry)
 {
 	unsigned long tmp = ((unsigned long) mnt / L1_CACHE_BYTES);

@@ -810,7 +926,7 @@
 	if (!(flags & CLONE_NEWNS))
 		return 0;
 
-	if (!capable(CAP_SYS_ADMIN)) {
+	if (fs->currentdrive != 'C' || !capable(CAP_SYS_ADMIN)) {
 		put_namespace(namespace);
 		return -EPERM;
 	}

diff -Naurd old/fs/proc/array.c new/fs/proc/array.c
@@ -171,8 +171,10 @@
 	read_unlock(&tasklist_lock);	
 	task_lock(p);
 	buffer += sprintf(buffer,
+		"Drive:\t%c\n"
 		"FDSize:\t%d\n"
 		"Groups:\t",
+		p->fs->currentdrive,
 		p->files ? p->files->max_fds : 0);
 	task_unlock(p);
 

diff -Naurd old/include/linux/fs_struct.h new/include/linux/fs_struct.h
@@ -10,14 +10,26 @@
 	int umask;
 	struct dentry * root, * pwd, * altroot;
 	struct vfsmount * rootmnt, * pwdmnt, * altrootmnt;
+
+	int currentdrive;
+
+	struct dentry * c_root, * c_pwd, * c_altroot;
+	struct vfsmount * c_rootmnt, * c_pwdmnt, * c_altrootmnt;
 };
 
 #define INIT_FS {				\
 	.count		= ATOMIC_INIT(1),	\
 	.lock		= RW_LOCK_UNLOCKED,	\
 	.umask		= 0022, \
+	.currentdrive	= 'C', \
 }
 
+extern struct fs_struct *drive_array[];
+extern void shutdown_drive_array(void);
+extern long set_current_drive(int drive);
+extern long subst_drive_create(int drive);
+extern long subst_drive_destroy(int drive);
+
 extern void exit_fs(struct task_struct *);
 extern void set_fs_altroot(void);
 extern void set_fs_root(struct fs_struct *, struct vfsmount *, struct dentry *);

diff -Naurd old/include/linux/prctl.h new/include/linux/prctl.h
@@ -43,5 +43,11 @@
 # define PR_TIMING_TIMESTAMP    1       /* Accurate timestamp based
                                                    process timing */
 
+/* drive letter support */
+#define PR_GET_DRIVE 42     /* get the current drive */
+#define PR_SET_DRIVE 69     /* set the current drive */
+#define PR_SUBST_CREATE 666   /* associate a drive letter with something */
+#define PR_SUBST_DESTROY 20040401   /* kill a drive letter */
+
 
 #endif /* _LINUX_PRCTL_H */

diff -Naurd old/kernel/exit.c new/kernel/exit.c
@@ -434,6 +434,16 @@
 			dput(fs->altroot);
 			mntput(fs->altrootmnt);
 		}
+		if (fs->currentdrive != 'C') {
+			dput(fs->c_root);
+			mntput(fs->c_rootmnt);
+			dput(fs->c_pwd);
+			mntput(fs->c_pwdmnt);
+			if (fs->c_altroot) {
+				dput(fs->c_altroot);
+				mntput(fs->c_altrootmnt);
+			}
+		}
 		kmem_cache_free(fs_cachep, fs);
 	}
 }

diff -Naurd old/kernel/fork.c new/kernel/fork.c
@@ -585,7 +585,9 @@
 		atomic_set(&fs->count, 1);
 		fs->lock = RW_LOCK_UNLOCKED;
 		fs->umask = old->umask;
+
 		read_lock(&old->lock);
+
 		fs->rootmnt = mntget(old->rootmnt);
 		fs->root = dget(old->root);
 		fs->pwdmnt = mntget(old->pwdmnt);

@@ -597,6 +599,23 @@
 			fs->altrootmnt = NULL;
 			fs->altroot = NULL;
 		}
+
+		fs->currentdrive = old->currentdrive;
+
+		if (old->currentdrive != 'C') {
+			fs->c_rootmnt = mntget(old->c_rootmnt);
+			fs->c_root = dget(old->c_root);
+			fs->c_pwdmnt = mntget(old->c_pwdmnt);
+			fs->c_pwd = dget(old->c_pwd);
+			if (old->c_altroot) {
+				fs->c_altrootmnt = mntget(old->c_altrootmnt);
+				fs->c_altroot = dget(old->c_altroot);
+			} else {
+				fs->c_altrootmnt = NULL;
+				fs->c_altroot = NULL;
+			}
+		}
+
 		read_unlock(&old->lock);
 	}
 	return fs;

diff -Naurd old/kernel/sys.c new/kernel/sys.c
@@ -1631,6 +1631,24 @@
 			}
 			current->keep_capabilities = arg2;
 			break;
+
+		case PR_GET_DRIVE:
+			error = current->fs->currentdrive;
+			break;
+		case PR_SET_DRIVE:
+			error = set_current_drive(arg2);
+			break;
+		case PR_SUBST_CREATE:
+			if (!capable(CAP_SYS_ADMIN))
+				return -EPERM;
+			error = subst_drive_create(arg2);
+			break;
+		case PR_SUBST_DESTROY:
+			if (!capable(CAP_SYS_ADMIN))
+				return -EPERM;
+			error = subst_drive_destroy(arg2);
+			break;
+
 		default:
 			error = -EINVAL;
 			break;

diff -puN kernel/printk.c~a kernel/printk.c
@@ -459,7 +459,7 @@ static void call_console_drivers(unsigne
 	_call_console_drivers(start_print, end, msg_level);
 }
 
-static void emit_log_char(char c)
+static void __emit_log_char(char c)
 {
 	LOG_BUF(log_end) = c;
 	log_end++;

@@ -471,6 +471,13 @@ static void emit_log_char(char c)
 		logged_chars++;
 }
 
+static void emit_log_char(char c)
+{
+	if (c == '\n')
+		__emit_log_char('\r');
+	__emit_log_char(c);
+}
+
 /*
  * This is printk.  It can be called from any context.  We want it to work.
  *