1 files changed, 281 insertions, 0 deletions
diff --git a/src/fs/super.c b/src/fs/super.c
new file mode 100644
index 0000000..39c4089
--- /dev/null
+++ b/src/fs/super.c
@@ -0,0 +1,281 @@
+/*
+ *  linux/fs/super.c
+ *
+ *  (C) 1991  Linus Torvalds
+ */
+/*
+ * super.c contains code to handle the super-block tables.
+ */
+#include <linux/config.h>
+#include <linux/sched.h>
+#include <linux/kernel.h>
+#include <asm/system.h>
+#include <errno.h>
+#include <sys/stat.h>
+int sync_dev(int dev);
+void wait_for_keypress(void);
+/* set_bit uses setb, as gas doesn't recognize setc */
+#define set_bit(bitnr,addr) ({ \
+register int __res ; \
+__asm__("bt %2,%3;setb %%al":"=a" (__res):"a" (0),"r" (bitnr),"m" (*(addr))); \
+__res; })
+struct super_block super_block[NR_SUPER];
+/* this is initialized in init/main.c */
+int ROOT_DEV = 0;
+static void lock_super(struct super_block * sb)
+{
+        cli();
+        while (sb->s_lock)
+                sleep_on(&(sb->s_wait));
+        sb->s_lock = 1;
+        sti();
+}
+static void free_super(struct super_block * sb)
+{
+        cli();
+        sb->s_lock = 0;
+        wake_up(&(sb->s_wait));
+        sti();
+}
+static void wait_on_super(struct super_block * sb)
+{
+        cli();
+        while (sb->s_lock)
+                sleep_on(&(sb->s_wait));
+        sti();
+}
+struct super_block * get_super(int dev)
+{
+        struct super_block * s;
+        if (!dev)
+                return NULL;
+        s = 0+super_block;
+        while (s < NR_SUPER+super_block)
+                if (s->s_dev == dev) {
+                        wait_on_super(s);
+                        if (s->s_dev == dev)
+                                return s;
+                        s = 0+super_block;
+                } else
+                        s++;
+        return NULL;
+}
+void put_super(int dev)
+{
+        struct super_block * sb;
+        /* struct m_inode * inode;*/
+        int i;
+        if (dev == ROOT_DEV) {
+                printk("root diskette changed: prepare for armageddon\n\r");
+                return;
+        }
+        if (!(sb = get_super(dev)))
+                return;
+        if (sb->s_imount) {
+                printk("Mounted disk changed - tssk, tssk\n\r");
+                return;
+        }
+        lock_super(sb);
+        sb->s_dev = 0;
+        for(i=0;i<I_MAP_SLOTS;i++)
+                brelse(sb->s_imap[i]);
+        for(i=0;i<Z_MAP_SLOTS;i++)
+                brelse(sb->s_zmap[i]);
+        free_super(sb);
+        return;
+}
+static struct super_block * read_super(int dev)
+{
+        struct super_block * s;
+        struct buffer_head * bh;
+        int i,block;
+        if (!dev)
+                return NULL;
+        check_disk_change(dev);
+        if ((s = get_super(dev)))
+                return s;
+        for (s = 0+super_block ;; s++) {
+                if (s >= NR_SUPER+super_block)
+                        return NULL;
+                if (!s->s_dev)
+                        break;
+        }
+        s->s_dev = dev;
+        s->s_isup = NULL;
+        s->s_imount = NULL;
+        s->s_time = 0;
+        s->s_rd_only = 0;
+        s->s_dirt = 0;
+        lock_super(s);
+        if (!(bh = bread(dev,1))) {
+                s->s_dev=0;
+                free_super(s);
+                return NULL;
+        }
+        *((struct d_super_block *) s) =
+                *((struct d_super_block *) bh->b_data);
+        brelse(bh);
+        if (s->s_magic != SUPER_MAGIC) {
+                s->s_dev = 0;
+                free_super(s);
+                return NULL;
+        }
+        for (i=0;i<I_MAP_SLOTS;i++)
+                s->s_imap[i] = NULL;
+        for (i=0;i<Z_MAP_SLOTS;i++)
+                s->s_zmap[i] = NULL;
+        block=2;
+        for (i=0 ; i < s->s_imap_blocks ; i++)
+                if ((s->s_imap[i]=bread(dev,block)))
+                        block++;
+                else
+                        break;
+        for (i=0 ; i < s->s_zmap_blocks ; i++)
+                if ((s->s_zmap[i]=bread(dev,block)))
+                        block++;
+                else
+                        break;
+        if (block != 2+s->s_imap_blocks+s->s_zmap_blocks) {
+                for(i=0;i<I_MAP_SLOTS;i++)
+                        brelse(s->s_imap[i]);
+                for(i=0;i<Z_MAP_SLOTS;i++)
+                        brelse(s->s_zmap[i]);
+                s->s_dev=0;
+                free_super(s);
+                return NULL;
+        }
+        s->s_imap[0]->b_data[0] |= 1;
+        s->s_zmap[0]->b_data[0] |= 1;
+        free_super(s);
+        return s;
+}
+int sys_umount(char * dev_name)
+{
+        struct m_inode * inode;
+        struct super_block * sb;
+        int dev;
+        if (!(inode=namei(dev_name)))
+                return -ENOENT;
+        dev = inode->i_zone[0];
+        if (!S_ISBLK(inode->i_mode)) {
+                iput(inode);
+                return -ENOTBLK;
+        }
+        iput(inode);
+        if (dev==ROOT_DEV)
+                return -EBUSY;
+        if (!(sb=get_super(dev)) || !(sb->s_imount))
+                return -ENOENT;
+        if (!sb->s_imount->i_mount)
+                printk("Mounted inode has i_mount=0\n");
+        for (inode=inode_table+0 ; inode<inode_table+NR_INODE ; inode++)
+                if (inode->i_dev==dev && inode->i_count)
+                                return -EBUSY;
+        sb->s_imount->i_mount=0;
+        iput(sb->s_imount);
+        sb->s_imount = NULL;
+        iput(sb->s_isup);
+        sb->s_isup = NULL;
+        put_super(dev);
+        sync_dev(dev);
+        return 0;
+}
+int sys_mount(char * dev_name, char * dir_name, int rw_flag)
+{
+        struct m_inode * dev_i, * dir_i;
+        struct super_block * sb;
+        int dev;
+        if (!(dev_i=namei(dev_name)))
+                return -ENOENT;
+        dev = dev_i->i_zone[0];
+        if (!S_ISBLK(dev_i->i_mode)) {
+                iput(dev_i);
+                return -EPERM;
+        }
+        iput(dev_i);
+        if (!(dir_i=namei(dir_name)))
+                return -ENOENT;
+        if (dir_i->i_count != 1 || dir_i->i_num == ROOT_INO) {
+                iput(dir_i);
+                return -EBUSY;
+        }
+        if (!S_ISDIR(dir_i->i_mode)) {
+                iput(dir_i);
+                return -EPERM;
+        }
+        if (!(sb=read_super(dev))) {
+                iput(dir_i);
+                return -EBUSY;
+        }
+        if (sb->s_imount) {
+                iput(dir_i);
+                return -EBUSY;
+        }
+        if (dir_i->i_mount) {
+                iput(dir_i);
+                return -EPERM;
+        }
+        sb->s_imount=dir_i;
+        dir_i->i_mount=1;
+        dir_i->i_dirt=1;                /* NOTE! we don't iput(dir_i) */
+        return 0;                       /* we do that in umount */
+}
+void mount_root(void)
+{
+        int i,free;
+        struct super_block * p;
+        struct m_inode * mi;
+        if (32 != sizeof (struct d_inode))
+                panic("bad i-node size");
+        for(i=0;i<NR_FILE;i++)
+                file_table[i].f_count=0;
+        if (MAJOR(ROOT_DEV) == 2) {
+                printk("Insert root floppy and press ENTER");
+                wait_for_keypress();
+        }
+        for(p = &super_block[0] ; p < &super_block[NR_SUPER] ; p++) {
+                p->s_dev = 0;
+                p->s_lock = 0;
+                p->s_wait = NULL;
+        }
+        if (!(p=read_super(ROOT_DEV)))
+                panic("Unable to mount root");
+        if (!(mi=iget(ROOT_DEV,ROOT_INO)))
+                panic("Unable to read root i-node");
+        mi->i_count += 3 ;      /* NOTE! it is logically used 4 times, not 1 */
+        p->s_isup = p->s_imount = mi;
+        current->pwd = mi;
+        current->root = mi;
+        free=0;
+        i=p->s_nzones;
+        while (-- i >= 0)
+                if (!set_bit(i&8191,p->s_zmap[i>>13]->b_data))
+                        free++;
+        printk("%d/%d free blocks\n\r",free,p->s_nzones);
+        free=0;
+        i=p->s_ninodes+1;
+        while (-- i >= 0)
+                if (!set_bit(i&8191,p->s_imap[i>>13]->b_data))
+                        free++;
+        printk("%d/%d free inodes\n\r",free,p->s_ninodes);
+}

diff --git a/src/fs/super.c b/src/fs/super.c new file mode 100644 index 0000000..39c4089 --- /dev/null +++ b/src/fs/super.c
@@ -0,0 +1,281 @@
	1	/*
	2	* linux/fs/super.c
	3	*
	4	* (C) 1991 Linus Torvalds
	5	*/
	6
	7	/*
	8	* super.c contains code to handle the super-block tables.
	9	*/
	10	#include <linux/config.h>
	11	#include <linux/sched.h>
	12	#include <linux/kernel.h>
	13	#include <asm/system.h>
	14
	15	#include <errno.h>
	16	#include <sys/stat.h>
	17
	18	int sync_dev(int dev);
	19	void wait_for_keypress(void);
	20
	21	/* set_bit uses setb, as gas doesn't recognize setc */
	22	#define set_bit(bitnr,addr) ({ \
	23	register int __res ; \
	24	__asm__("bt %2,%3;setb %%al":"=a" (__res):"a" (0),"r" (bitnr),"m" (*(addr))); \
	25	__res; })
	26
	27	struct super_block super_block[NR_SUPER];
	28	/* this is initialized in init/main.c */
	29	int ROOT_DEV = 0;
	30
	31	static void lock_super(struct super_block * sb)
	32	{
	33	cli();
	34	while (sb->s_lock)
	35	sleep_on(&(sb->s_wait));
	36	sb->s_lock = 1;
	37	sti();
	38	}
	39
	40	static void free_super(struct super_block * sb)
	41	{
	42	cli();
	43	sb->s_lock = 0;
	44	wake_up(&(sb->s_wait));
	45	sti();
	46	}
	47
	48	static void wait_on_super(struct super_block * sb)
	49	{
	50	cli();
	51	while (sb->s_lock)
	52	sleep_on(&(sb->s_wait));
	53	sti();
	54	}
	55
	56	struct super_block * get_super(int dev)
	57	{
	58	struct super_block * s;
	59
	60	if (!dev)
	61	return NULL;
	62	s = 0+super_block;
	63	while (s < NR_SUPER+super_block)
	64	if (s->s_dev == dev) {
	65	wait_on_super(s);
	66	if (s->s_dev == dev)
	67	return s;
	68	s = 0+super_block;
	69	} else
	70	s++;
	71	return NULL;
	72	}
	73
	74	void put_super(int dev)
	75	{
	76	struct super_block * sb;
	77	/* struct m_inode * inode;*/
	78	int i;
	79
	80	if (dev == ROOT_DEV) {
	81	printk("root diskette changed: prepare for armageddon\n\r");
	82	return;
	83	}
	84	if (!(sb = get_super(dev)))
	85	return;
	86	if (sb->s_imount) {
	87	printk("Mounted disk changed - tssk, tssk\n\r");
	88	return;
	89	}
	90	lock_super(sb);
	91	sb->s_dev = 0;
	92	for(i=0;i<I_MAP_SLOTS;i++)
	93	brelse(sb->s_imap[i]);
	94	for(i=0;i<Z_MAP_SLOTS;i++)
	95	brelse(sb->s_zmap[i]);
	96	free_super(sb);
	97	return;
	98	}
	99
	100	static struct super_block * read_super(int dev)
	101	{
	102	struct super_block * s;
	103	struct buffer_head * bh;
	104	int i,block;
	105
	106	if (!dev)
	107	return NULL;
	108	check_disk_change(dev);
	109	if ((s = get_super(dev)))
	110	return s;
	111	for (s = 0+super_block ;; s++) {
	112	if (s >= NR_SUPER+super_block)
	113	return NULL;
	114	if (!s->s_dev)
	115	break;
	116	}
	117	s->s_dev = dev;
	118	s->s_isup = NULL;
	119	s->s_imount = NULL;
	120	s->s_time = 0;
	121	s->s_rd_only = 0;
	122	s->s_dirt = 0;
	123	lock_super(s);
	124	if (!(bh = bread(dev,1))) {
	125	s->s_dev=0;
	126	free_super(s);
	127	return NULL;
	128	}
	129	((struct d_super_block ) s) =
	130	((struct d_super_block ) bh->b_data);
	131	brelse(bh);
	132	if (s->s_magic != SUPER_MAGIC) {
	133	s->s_dev = 0;
	134	free_super(s);
	135	return NULL;
	136	}
	137	for (i=0;i<I_MAP_SLOTS;i++)
	138	s->s_imap[i] = NULL;
	139	for (i=0;i<Z_MAP_SLOTS;i++)
	140	s->s_zmap[i] = NULL;
	141	block=2;
	142	for (i=0 ; i < s->s_imap_blocks ; i++)
	143	if ((s->s_imap[i]=bread(dev,block)))
	144	block++;
	145	else
	146	break;
	147	for (i=0 ; i < s->s_zmap_blocks ; i++)
	148	if ((s->s_zmap[i]=bread(dev,block)))
	149	block++;
	150	else
	151	break;
	152	if (block != 2+s->s_imap_blocks+s->s_zmap_blocks) {
	153	for(i=0;i<I_MAP_SLOTS;i++)
	154	brelse(s->s_imap[i]);
	155	for(i=0;i<Z_MAP_SLOTS;i++)
	156	brelse(s->s_zmap[i]);
	157	s->s_dev=0;
	158	free_super(s);
	159	return NULL;
	160	}
	161	s->s_imap[0]->b_data[0] \|= 1;
	162	s->s_zmap[0]->b_data[0] \|= 1;
	163	free_super(s);
	164	return s;
	165	}
	166
	167	int sys_umount(char * dev_name)
	168	{
	169	struct m_inode * inode;
	170	struct super_block * sb;
	171	int dev;
	172
	173	if (!(inode=namei(dev_name)))
	174	return -ENOENT;
	175	dev = inode->i_zone[0];
	176	if (!S_ISBLK(inode->i_mode)) {
	177	iput(inode);
	178	return -ENOTBLK;
	179	}
	180	iput(inode);
	181	if (dev==ROOT_DEV)
	182	return -EBUSY;
	183	if (!(sb=get_super(dev)) \|\| !(sb->s_imount))
	184	return -ENOENT;
	185	if (!sb->s_imount->i_mount)
	186	printk("Mounted inode has i_mount=0\n");
	187	for (inode=inode_table+0 ; inode<inode_table+NR_INODE ; inode++)
	188	if (inode->i_dev==dev && inode->i_count)
	189	return -EBUSY;
	190	sb->s_imount->i_mount=0;
	191	iput(sb->s_imount);
	192	sb->s_imount = NULL;
	193	iput(sb->s_isup);
	194	sb->s_isup = NULL;
	195	put_super(dev);
	196	sync_dev(dev);
	197	return 0;
	198	}
	199
	200	int sys_mount(char * dev_name, char * dir_name, int rw_flag)
	201	{
	202	struct m_inode * dev_i, * dir_i;
	203	struct super_block * sb;
	204	int dev;
	205
	206	if (!(dev_i=namei(dev_name)))
	207	return -ENOENT;
	208	dev = dev_i->i_zone[0];
	209	if (!S_ISBLK(dev_i->i_mode)) {
	210	iput(dev_i);
	211	return -EPERM;
	212	}
	213	iput(dev_i);
	214	if (!(dir_i=namei(dir_name)))
	215	return -ENOENT;
	216	if (dir_i->i_count != 1 \|\| dir_i->i_num == ROOT_INO) {
	217	iput(dir_i);
	218	return -EBUSY;
	219	}
	220	if (!S_ISDIR(dir_i->i_mode)) {
	221	iput(dir_i);
	222	return -EPERM;
	223	}
	224	if (!(sb=read_super(dev))) {
	225	iput(dir_i);
	226	return -EBUSY;
	227	}
	228	if (sb->s_imount) {
	229	iput(dir_i);
	230	return -EBUSY;
	231	}
	232	if (dir_i->i_mount) {
	233	iput(dir_i);
	234	return -EPERM;
	235	}
	236	sb->s_imount=dir_i;
	237	dir_i->i_mount=1;
	238	dir_i->i_dirt=1; /* NOTE! we don't iput(dir_i) */
	239	return 0; /* we do that in umount */
	240	}
	241
	242	void mount_root(void)
	243	{
	244	int i,free;
	245	struct super_block * p;
	246	struct m_inode * mi;
	247
	248	if (32 != sizeof (struct d_inode))
	249	panic("bad i-node size");
	250	for(i=0;i<NR_FILE;i++)
	251	file_table[i].f_count=0;
	252	if (MAJOR(ROOT_DEV) == 2) {
	253	printk("Insert root floppy and press ENTER");
	254	wait_for_keypress();
	255	}
	256	for(p = &super_block[0] ; p < &super_block[NR_SUPER] ; p++) {
	257	p->s_dev = 0;
	258	p->s_lock = 0;
	259	p->s_wait = NULL;
	260	}
	261	if (!(p=read_super(ROOT_DEV)))
	262	panic("Unable to mount root");
	263	if (!(mi=iget(ROOT_DEV,ROOT_INO)))
	264	panic("Unable to read root i-node");
	265	mi->i_count += 3 ; /* NOTE! it is logically used 4 times, not 1 */
	266	p->s_isup = p->s_imount = mi;
	267	current->pwd = mi;
	268	current->root = mi;
	269	free=0;
	270	i=p->s_nzones;
	271	while (-- i >= 0)
	272	if (!set_bit(i&8191,p->s_zmap[i>>13]->b_data))
	273	free++;
	274	printk("%d/%d free blocks\n\r",free,p->s_nzones);
	275	free=0;
	276	i=p->s_ninodes+1;
	277	while (-- i >= 0)
	278	if (!set_bit(i&8191,p->s_imap[i>>13]->b_data))
	279	free++;
	280	printk("%d/%d free inodes\n\r",free,p->s_ninodes);
	281	}