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