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