This source file includes following definitions.
- minix_put_super
- minix_read_super
- _minix_bmap
- minix_bmap
- minix_create_block
- minix_read_inode
- minix_write_inode
1
2
3
4
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
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
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)
98 {
99 struct buffer_head * bh;
100 int i;
101
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 }
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 {
171 return _minix_bmap(inode,block,0);
172 }
173
174 int minix_create_block(struct inode * inode, int block)
175 {
176 return _minix_bmap(inode,block,1);
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 }