![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to inode.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Early Linux] / linux / fs / minix|
Return to inode.c CVS log | Up to [Early Linux] / linux / fs / minix |
1.1 root 1: /*
2: * linux/fs/minix/inode.c
3: *
4: * (C) 1991 Linus Torvalds
5: */
6:
7: #include <string.h>
8: #include <sys/stat.h>
9:
10: #include <linux/sched.h>
11: #include <linux/minix_fs.h>
12: #include <linux/kernel.h>
13: #include <linux/mm.h>
14: #include <asm/system.h>
15:
1.1.1.2 ! root 16: int sync_dev(int dev);
! 17:
! 18: void minix_put_super(struct super_block *sb)
! 19: {
! 20: int i;
! 21:
! 22: lock_super(sb);
! 23: sb->s_dev = 0;
! 24: for(i = 0 ; i < MINIX_I_MAP_SLOTS ; i++)
! 25: brelse(sb->s_imap[i]);
! 26: for(i = 0 ; i < MINIX_Z_MAP_SLOTS ; i++)
! 27: brelse(sb->s_zmap[i]);
! 28: free_super(sb);
! 29: return;
! 30: }
! 31:
! 32: static struct super_operations minix_sops = {
! 33: minix_read_inode,
! 34: minix_put_super
! 35: };
! 36:
! 37: struct super_block *minix_read_super(struct super_block *s,void *data)
! 38: {
! 39: struct buffer_head *bh;
! 40: int i,dev=s->s_dev,block;
! 41:
! 42: lock_super(s);
! 43: if (!(bh = bread(dev,1))) {
! 44: s->s_dev=0;
! 45: free_super(s);
! 46: printk("bread failed\n");
! 47: return NULL;
! 48: }
! 49: *((struct minix_super_block *) s) =
! 50: *((struct minix_super_block *) bh->b_data);
! 51: brelse(bh);
! 52: if (s->s_magic != MINIX_SUPER_MAGIC) {
! 53: s->s_dev = 0;
! 54: free_super(s);
! 55: printk("magic match failed\n");
! 56: return NULL;
! 57: }
! 58: for (i=0;i < MINIX_I_MAP_SLOTS;i++)
! 59: s->s_imap[i] = NULL;
! 60: for (i=0;i < MINIX_Z_MAP_SLOTS;i++)
! 61: s->s_zmap[i] = NULL;
! 62: block=2;
! 63: for (i=0 ; i < s->s_imap_blocks ; i++)
! 64: if (s->s_imap[i]=bread(dev,block))
! 65: block++;
! 66: else
! 67: break;
! 68: for (i=0 ; i < s->s_zmap_blocks ; i++)
! 69: if (s->s_zmap[i]=bread(dev,block))
! 70: block++;
! 71: else
! 72: break;
! 73: if (block != 2+s->s_imap_blocks+s->s_zmap_blocks) {
! 74: for(i=0;i<MINIX_I_MAP_SLOTS;i++)
! 75: brelse(s->s_imap[i]);
! 76: for(i=0;i<MINIX_Z_MAP_SLOTS;i++)
! 77: brelse(s->s_zmap[i]);
! 78: s->s_dev=0;
! 79: free_super(s);
! 80: printk("block failed\n");
! 81: return NULL;
! 82: }
! 83: s->s_imap[0]->b_data[0] |= 1;
! 84: s->s_zmap[0]->b_data[0] |= 1;
! 85: free_super(s);
! 86: /* set up enough so that it can read an inode */
! 87: s->s_dev = dev;
! 88: s->s_op = &minix_sops;
! 89: if (!(s->s_mounted = iget(dev,MINIX_ROOT_INO))) {
! 90: s->s_dev=0;
! 91: printk("get root inode failed\n");
! 92: return NULL;
! 93: }
! 94: return s;
! 95: }
! 96:
! 97: static int _minix_bmap(struct inode * inode,int block,int create)
1.1 root 98: {
99: struct buffer_head * bh;
100: int i;
101:
1.1.1.2 ! root 102: if (block<0) {
! 103: printk("_minix_bmap: block<0");
! 104: return 0;
! 105: }
! 106: if (block >= 7+512+512*512) {
! 107: printk("_minix_bmap: block>big");
! 108: return 0;
! 109: }
1.1 root 110: if (block<7) {
111: if (create && !inode->i_data[block])
112: if (inode->i_data[block]=minix_new_block(inode->i_dev)) {
113: inode->i_ctime=CURRENT_TIME;
114: inode->i_dirt=1;
115: }
116: return inode->i_data[block];
117: }
118: block -= 7;
119: if (block<512) {
120: if (create && !inode->i_data[7])
121: if (inode->i_data[7]=minix_new_block(inode->i_dev)) {
122: inode->i_dirt=1;
123: inode->i_ctime=CURRENT_TIME;
124: }
125: if (!inode->i_data[7])
126: return 0;
127: if (!(bh = bread(inode->i_dev,inode->i_data[7])))
128: return 0;
129: i = ((unsigned short *) (bh->b_data))[block];
130: if (create && !i)
131: if (i=minix_new_block(inode->i_dev)) {
132: ((unsigned short *) (bh->b_data))[block]=i;
133: bh->b_dirt=1;
134: }
135: brelse(bh);
136: return i;
137: }
138: block -= 512;
139: if (create && !inode->i_data[8])
140: if (inode->i_data[8]=minix_new_block(inode->i_dev)) {
141: inode->i_dirt=1;
142: inode->i_ctime=CURRENT_TIME;
143: }
144: if (!inode->i_data[8])
145: return 0;
146: if (!(bh=bread(inode->i_dev,inode->i_data[8])))
147: return 0;
148: i = ((unsigned short *)bh->b_data)[block>>9];
149: if (create && !i)
150: if (i=minix_new_block(inode->i_dev)) {
151: ((unsigned short *) (bh->b_data))[block>>9]=i;
152: bh->b_dirt=1;
153: }
154: brelse(bh);
155: if (!i)
156: return 0;
157: if (!(bh=bread(inode->i_dev,i)))
158: return 0;
159: i = ((unsigned short *)bh->b_data)[block&511];
160: if (create && !i)
161: if (i=minix_new_block(inode->i_dev)) {
162: ((unsigned short *) (bh->b_data))[block&511]=i;
163: bh->b_dirt=1;
164: }
165: brelse(bh);
166: return i;
167: }
168:
169: int minix_bmap(struct inode * inode,int block)
170: {
1.1.1.2 ! root 171: return _minix_bmap(inode,block,0);
1.1 root 172: }
173:
174: int minix_create_block(struct inode * inode, int block)
175: {
1.1.1.2 ! root 176: return _minix_bmap(inode,block,1);
1.1 root 177: }
178:
179: void minix_read_inode(struct inode * inode)
180: {
181: struct buffer_head * bh;
182: struct minix_inode * raw_inode;
183: int block;
184:
185: block = 2 + inode->i_sb->s_imap_blocks + inode->i_sb->s_zmap_blocks +
186: (inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
187: if (!(bh=bread(inode->i_dev,block)))
188: panic("unable to read i-node block");
189: raw_inode = ((struct minix_inode *) bh->b_data) +
190: (inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
191: inode->i_mode = raw_inode->i_mode;
192: inode->i_uid = raw_inode->i_uid;
193: inode->i_gid = raw_inode->i_gid;
194: inode->i_nlink = raw_inode->i_nlinks;
195: inode->i_size = raw_inode->i_size;
196: inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
197: if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
198: inode->i_rdev = raw_inode->i_zone[0];
199: else for (block = 0; block < 9; block++)
200: inode->i_data[block] = raw_inode->i_zone[block];
201: brelse(bh);
202: inode->i_op = &minix_inode_operations;
203: }
204:
205: void minix_write_inode(struct inode * inode)
206: {
207: struct buffer_head * bh;
208: struct minix_inode * raw_inode;
209: int block;
210:
211: block = 2 + inode->i_sb->s_imap_blocks + inode->i_sb->s_zmap_blocks +
212: (inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
213: if (!(bh=bread(inode->i_dev,block)))
214: panic("unable to read i-node block");
215: raw_inode = ((struct minix_inode *)bh->b_data) +
216: (inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
217: raw_inode->i_mode = inode->i_mode;
218: raw_inode->i_uid = inode->i_uid;
219: raw_inode->i_gid = inode->i_gid;
220: raw_inode->i_nlinks = inode->i_nlink;
221: raw_inode->i_size = inode->i_size;
222: raw_inode->i_time = inode->i_mtime;
223: if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
224: raw_inode->i_zone[0] = inode->i_rdev;
225: else for (block = 0; block < 9; block++)
226: raw_inode->i_zone[block] = inode->i_data[block];
227: bh->b_dirt=1;
228: inode->i_dirt=0;
229: brelse(bh);
230: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.