![[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.1.4 ! root 8: #include <linux/stat.h>
1.1 root 9: #include <linux/sched.h>
10: #include <linux/minix_fs.h>
11: #include <linux/kernel.h>
12: #include <linux/mm.h>
13: #include <asm/system.h>
1.1.1.4 ! root 14: #include <asm/segment.h>
1.1 root 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.4 ! root 43: minix_put_super,
! 44: minix_statfs
1.1.1.2 root 45: };
46:
47: struct super_block *minix_read_super(struct super_block *s,void *data)
48: {
49: struct buffer_head *bh;
1.1.1.4 ! root 50: struct minix_super_block *ms;
1.1.1.2 root 51: int i,dev=s->s_dev,block;
52:
53: lock_super(s);
54: if (!(bh = bread(dev,1))) {
55: s->s_dev=0;
56: free_super(s);
57: printk("bread failed\n");
58: return NULL;
59: }
1.1.1.4 ! root 60: ms = (struct minix_super_block *) bh->b_data;
! 61: s->s_ninodes = ms->s_ninodes;
! 62: s->s_nzones = ms->s_nzones;
! 63: s->s_imap_blocks = ms->s_imap_blocks;
! 64: s->s_zmap_blocks = ms->s_zmap_blocks;
! 65: s->s_firstdatazone = ms->s_firstdatazone;
! 66: s->s_log_zone_size = ms->s_log_zone_size;
! 67: s->s_max_size = ms->s_max_size;
! 68: s->s_magic = ms->s_magic;
1.1.1.2 root 69: brelse(bh);
70: if (s->s_magic != MINIX_SUPER_MAGIC) {
71: s->s_dev = 0;
72: free_super(s);
73: printk("magic match failed\n");
74: return NULL;
75: }
76: for (i=0;i < MINIX_I_MAP_SLOTS;i++)
77: s->s_imap[i] = NULL;
78: for (i=0;i < MINIX_Z_MAP_SLOTS;i++)
79: s->s_zmap[i] = NULL;
80: block=2;
81: for (i=0 ; i < s->s_imap_blocks ; i++)
82: if (s->s_imap[i]=bread(dev,block))
83: block++;
84: else
85: break;
86: for (i=0 ; i < s->s_zmap_blocks ; i++)
87: if (s->s_zmap[i]=bread(dev,block))
88: block++;
89: else
90: break;
91: if (block != 2+s->s_imap_blocks+s->s_zmap_blocks) {
92: for(i=0;i<MINIX_I_MAP_SLOTS;i++)
93: brelse(s->s_imap[i]);
94: for(i=0;i<MINIX_Z_MAP_SLOTS;i++)
95: brelse(s->s_zmap[i]);
96: s->s_dev=0;
97: free_super(s);
98: printk("block failed\n");
99: return NULL;
100: }
101: s->s_imap[0]->b_data[0] |= 1;
102: s->s_zmap[0]->b_data[0] |= 1;
103: free_super(s);
104: /* set up enough so that it can read an inode */
105: s->s_dev = dev;
106: s->s_op = &minix_sops;
107: if (!(s->s_mounted = iget(dev,MINIX_ROOT_INO))) {
108: s->s_dev=0;
109: printk("get root inode failed\n");
110: return NULL;
111: }
112: return s;
113: }
114:
1.1.1.4 ! root 115: void minix_statfs (struct super_block *sb, struct statfs *buf)
! 116: {
! 117: long tmp;
! 118:
! 119: put_fs_long(MINIX_SUPER_MAGIC, &buf->f_type);
! 120: put_fs_long(1024, &buf->f_bsize);
! 121: put_fs_long(sb->s_nzones << sb->s_log_zone_size, &buf->f_blocks);
! 122: tmp = minix_count_free_blocks(sb);
! 123: put_fs_long(tmp, &buf->f_bfree);
! 124: put_fs_long(tmp, &buf->f_bavail);
! 125: put_fs_long(sb->s_ninodes, &buf->f_files);
! 126: put_fs_long(minix_count_free_inodes(sb), &buf->f_ffree);
! 127: /* Don't know what value to put in buf->f_fsid */
! 128: }
! 129:
1.1.1.2 root 130: static int _minix_bmap(struct inode * inode,int block,int create)
1.1 root 131: {
132: struct buffer_head * bh;
133: int i;
134:
1.1.1.2 root 135: if (block<0) {
136: printk("_minix_bmap: block<0");
137: return 0;
138: }
139: if (block >= 7+512+512*512) {
140: printk("_minix_bmap: block>big");
141: return 0;
142: }
1.1 root 143: if (block<7) {
144: if (create && !inode->i_data[block])
145: if (inode->i_data[block]=minix_new_block(inode->i_dev)) {
146: inode->i_ctime=CURRENT_TIME;
147: inode->i_dirt=1;
148: }
149: return inode->i_data[block];
150: }
151: block -= 7;
152: if (block<512) {
153: if (create && !inode->i_data[7])
154: if (inode->i_data[7]=minix_new_block(inode->i_dev)) {
155: inode->i_dirt=1;
156: inode->i_ctime=CURRENT_TIME;
157: }
158: if (!inode->i_data[7])
159: return 0;
160: if (!(bh = bread(inode->i_dev,inode->i_data[7])))
161: return 0;
162: i = ((unsigned short *) (bh->b_data))[block];
163: if (create && !i)
164: if (i=minix_new_block(inode->i_dev)) {
165: ((unsigned short *) (bh->b_data))[block]=i;
166: bh->b_dirt=1;
167: }
168: brelse(bh);
169: return i;
170: }
171: block -= 512;
172: if (create && !inode->i_data[8])
173: if (inode->i_data[8]=minix_new_block(inode->i_dev)) {
174: inode->i_dirt=1;
175: inode->i_ctime=CURRENT_TIME;
176: }
177: if (!inode->i_data[8])
178: return 0;
179: if (!(bh=bread(inode->i_dev,inode->i_data[8])))
180: return 0;
181: i = ((unsigned short *)bh->b_data)[block>>9];
182: if (create && !i)
183: if (i=minix_new_block(inode->i_dev)) {
184: ((unsigned short *) (bh->b_data))[block>>9]=i;
185: bh->b_dirt=1;
186: }
187: brelse(bh);
188: if (!i)
189: return 0;
190: if (!(bh=bread(inode->i_dev,i)))
191: return 0;
192: i = ((unsigned short *)bh->b_data)[block&511];
193: if (create && !i)
194: if (i=minix_new_block(inode->i_dev)) {
195: ((unsigned short *) (bh->b_data))[block&511]=i;
196: bh->b_dirt=1;
197: }
198: brelse(bh);
199: return i;
200: }
201:
202: int minix_bmap(struct inode * inode,int block)
203: {
1.1.1.2 root 204: return _minix_bmap(inode,block,0);
1.1 root 205: }
206:
207: int minix_create_block(struct inode * inode, int block)
208: {
1.1.1.2 root 209: return _minix_bmap(inode,block,1);
1.1 root 210: }
211:
212: void minix_read_inode(struct inode * inode)
213: {
214: struct buffer_head * bh;
215: struct minix_inode * raw_inode;
216: int block;
217:
218: block = 2 + inode->i_sb->s_imap_blocks + inode->i_sb->s_zmap_blocks +
219: (inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
220: if (!(bh=bread(inode->i_dev,block)))
221: panic("unable to read i-node block");
222: raw_inode = ((struct minix_inode *) bh->b_data) +
223: (inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
224: inode->i_mode = raw_inode->i_mode;
225: inode->i_uid = raw_inode->i_uid;
226: inode->i_gid = raw_inode->i_gid;
227: inode->i_nlink = raw_inode->i_nlinks;
228: inode->i_size = raw_inode->i_size;
229: inode->i_mtime = inode->i_atime = inode->i_ctime = raw_inode->i_time;
230: if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
231: inode->i_rdev = raw_inode->i_zone[0];
232: else for (block = 0; block < 9; block++)
233: inode->i_data[block] = raw_inode->i_zone[block];
234: brelse(bh);
1.1.1.3 root 235: inode->i_op = NULL;
236: if (S_ISREG(inode->i_mode))
237: inode->i_op = &minix_file_inode_operations;
238: else if (S_ISDIR(inode->i_mode))
239: inode->i_op = &minix_dir_inode_operations;
240: else if (S_ISLNK(inode->i_mode))
241: inode->i_op = &minix_symlink_inode_operations;
242: else if (S_ISCHR(inode->i_mode))
243: inode->i_op = &minix_chrdev_inode_operations;
244: else if (S_ISBLK(inode->i_mode))
245: inode->i_op = &minix_blkdev_inode_operations;
1.1 root 246: }
247:
248: void minix_write_inode(struct inode * inode)
249: {
250: struct buffer_head * bh;
251: struct minix_inode * raw_inode;
252: int block;
253:
254: block = 2 + inode->i_sb->s_imap_blocks + inode->i_sb->s_zmap_blocks +
255: (inode->i_ino-1)/MINIX_INODES_PER_BLOCK;
256: if (!(bh=bread(inode->i_dev,block)))
257: panic("unable to read i-node block");
258: raw_inode = ((struct minix_inode *)bh->b_data) +
259: (inode->i_ino-1)%MINIX_INODES_PER_BLOCK;
260: raw_inode->i_mode = inode->i_mode;
261: raw_inode->i_uid = inode->i_uid;
262: raw_inode->i_gid = inode->i_gid;
263: raw_inode->i_nlinks = inode->i_nlink;
264: raw_inode->i_size = inode->i_size;
265: raw_inode->i_time = inode->i_mtime;
266: if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
267: raw_inode->i_zone[0] = inode->i_rdev;
268: else for (block = 0; block < 9; block++)
269: raw_inode->i_zone[block] = inode->i_data[block];
270: bh->b_dirt=1;
271: inode->i_dirt=0;
272: brelse(bh);
273: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.