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