This source file includes following definitions.
- xiafs_put_inode
- xiafs_put_super
- xiafs_read_super
- xiafs_statfs
- zone_bmap
- xiafs_bmap
- get_prev_addr
- dt_getblk
- indt_getblk
- xiafs_getblk
- xiafs_bread
- xiafs_read_inode
- xiafs_update_inode
- xiafs_write_inode
- xiafs_sync_inode
1
2
3
4
5
6
7
8
9
10
11
12 #include <linux/sched.h>
13 #include <linux/xia_fs.h>
14 #include <linux/kernel.h>
15 #include <linux/mm.h>
16 #include <linux/string.h>
17 #include <linux/stat.h>
18 #include <linux/locks.h>
19 #include <asm/system.h>
20 #include <asm/segment.h>
21
22 #include "xiafs_mac.h"
23
24 static u_long random_nr;
25
26 void xiafs_put_inode(struct inode *inode)
27 {
28 if (inode->i_nlink)
29 return;
30 inode->i_size = 0;
31 xiafs_truncate(inode);
32 xiafs_free_inode(inode);
33 }
34
35 void xiafs_put_super(struct super_block *sb)
36 {
37 int i;
38
39 lock_super(sb);
40 sb->s_dev = 0;
41 for(i = 0 ; i < _XIAFS_IMAP_SLOTS ; i++)
42 brelse(sb->u.xiafs_sb.s_imap_buf[i]);
43 for(i = 0 ; i < _XIAFS_ZMAP_SLOTS ; i++)
44 brelse(sb->u.xiafs_sb.s_zmap_buf[i]);
45 unlock_super(sb);
46 }
47
48 static struct super_operations xiafs_sops = {
49 xiafs_read_inode,
50 NULL,
51 xiafs_write_inode,
52 xiafs_put_inode,
53 xiafs_put_super,
54 NULL,
55 xiafs_statfs,
56 NULL
57 };
58
59 struct super_block *xiafs_read_super(struct super_block *s, void *data,
60 int silent)
61 {
62 struct buffer_head *bh;
63 struct xiafs_super_block *sp;
64 int i, z, dev;
65
66 dev=s->s_dev;
67 lock_super(s);
68
69 set_blocksize(dev, BLOCK_SIZE);
70
71 if (!(bh = bread(dev, 0, BLOCK_SIZE))) {
72 s->s_dev=0;
73 unlock_super(s);
74 printk("XIA-FS: read super_block failed (%s %d)\n", WHERE_ERR);
75 return NULL;
76 }
77 sp = (struct xiafs_super_block *) bh->b_data;
78 s->s_magic = sp->s_magic;
79 if (s->s_magic != _XIAFS_SUPER_MAGIC) {
80 s->s_dev = 0;
81 unlock_super(s);
82 brelse(bh);
83 if (!silent)
84 printk("VFS: Can't find a xiafs filesystem on dev 0x%04x.\n",
85 dev);
86 return NULL;
87 }
88 s->s_blocksize = sp->s_zone_size;
89 s->s_blocksize_bits = 10 + sp->s_zone_shift;
90 if (s->s_blocksize != BLOCK_SIZE &&
91 (s->s_blocksize == 1024 || s->s_blocksize == 2048 ||
92 s->s_blocksize == 4096)) {
93 brelse(bh);
94 set_blocksize(dev, s->s_blocksize);
95 bh = bread (dev, 0, s->s_blocksize);
96 if(!bh) return NULL;
97 sp = (struct xiafs_super_block *) (((char *)bh->b_data) + BLOCK_SIZE) ;
98 };
99 s->u.xiafs_sb.s_nzones = sp->s_nzones;
100 s->u.xiafs_sb.s_ninodes = sp->s_ninodes;
101 s->u.xiafs_sb.s_ndatazones = sp->s_ndatazones;
102 s->u.xiafs_sb.s_imap_zones = sp->s_imap_zones;
103 s->u.xiafs_sb.s_zmap_zones = sp->s_zmap_zones;
104 s->u.xiafs_sb.s_firstdatazone = sp->s_firstdatazone;
105 s->u.xiafs_sb.s_zone_shift = sp->s_zone_shift;
106 s->u.xiafs_sb.s_max_size = sp->s_max_size;
107 brelse(bh);
108 for (i=0;i < _XIAFS_IMAP_SLOTS;i++) {
109 s->u.xiafs_sb.s_imap_buf[i] = NULL;
110 s->u.xiafs_sb.s_imap_iznr[i] = -1;
111 }
112 for (i=0;i < _XIAFS_ZMAP_SLOTS;i++) {
113 s->u.xiafs_sb.s_zmap_buf[i] = NULL;
114 s->u.xiafs_sb.s_zmap_zznr[i] = -1;
115 }
116 z=1;
117 if ( s->u.xiafs_sb.s_imap_zones > _XIAFS_IMAP_SLOTS )
118 s->u.xiafs_sb.s_imap_cached=1;
119 else {
120 s->u.xiafs_sb.s_imap_cached=0;
121 for (i=0 ; i < s->u.xiafs_sb.s_imap_zones ; i++) {
122 if (!(s->u.xiafs_sb.s_imap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
123 goto xiafs_read_super_fail;
124 s->u.xiafs_sb.s_imap_iznr[i]=i;
125 }
126 }
127 if ( s->u.xiafs_sb.s_zmap_zones > _XIAFS_ZMAP_SLOTS )
128 s->u.xiafs_sb.s_zmap_cached=1;
129 else {
130 s->u.xiafs_sb.s_zmap_cached=0;
131 for (i=0 ; i < s->u.xiafs_sb.s_zmap_zones ; i++) {
132 if (!(s->u.xiafs_sb.s_zmap_buf[i]=bread(dev, z++, XIAFS_ZSIZE(s))))
133 goto xiafs_read_super_fail;
134 s->u.xiafs_sb.s_zmap_zznr[i]=i;
135 }
136 }
137
138 s->s_dev = dev;
139 s->s_op = &xiafs_sops;
140 s->s_mounted = iget(s, _XIAFS_ROOT_INO);
141 if (!s->s_mounted)
142 goto xiafs_read_super_fail;
143 unlock_super(s);
144 random_nr=CURRENT_TIME;
145 return s;
146
147 xiafs_read_super_fail:
148 for(i=0; i < _XIAFS_IMAP_SLOTS; i++)
149 brelse(s->u.xiafs_sb.s_imap_buf[i]);
150 for(i=0; i < _XIAFS_ZMAP_SLOTS; i++)
151 brelse(s->u.xiafs_sb.s_zmap_buf[i]);
152 s->s_dev=0;
153 unlock_super(s);
154 printk("XIA-FS: read bitmaps failed (%s %d)\n", WHERE_ERR);
155 return NULL;
156 }
157
158 void xiafs_statfs(struct super_block *sb, struct statfs *buf)
159 {
160 long tmp;
161
162 put_fs_long(_XIAFS_SUPER_MAGIC, &buf->f_type);
163 put_fs_long(XIAFS_ZSIZE(sb), &buf->f_bsize);
164 put_fs_long(sb->u.xiafs_sb.s_ndatazones, &buf->f_blocks);
165 tmp = xiafs_count_free_zones(sb);
166 put_fs_long(tmp, &buf->f_bfree);
167 put_fs_long(tmp, &buf->f_bavail);
168 put_fs_long(sb->u.xiafs_sb.s_ninodes, &buf->f_files);
169 put_fs_long(xiafs_count_free_inodes(sb), &buf->f_ffree);
170 put_fs_long(_XIAFS_NAME_LEN, &buf->f_namelen);
171
172 }
173
174 static int zone_bmap(struct buffer_head * bh, int nr)
175 {
176 int tmp;
177
178 if (!bh)
179 return 0;
180 tmp = ((u_long *) bh->b_data)[nr];
181 brelse(bh);
182 return tmp;
183 }
184
185 int xiafs_bmap(struct inode * inode,int zone)
186 {
187 int i;
188
189 if (zone < 0) {
190 printk("XIA-FS: block < 0 (%s %d)\n", WHERE_ERR);
191 return 0;
192 }
193 if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
194 printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
195 return 0;
196 }
197 if (!IS_RDONLY (inode)) {
198 inode->i_atime = CURRENT_TIME;
199 inode->i_dirt = 1;
200 }
201 if (zone < 8)
202 return inode->u.xiafs_i.i_zone[zone];
203 zone -= 8;
204 if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
205 i = inode->u.xiafs_i.i_ind_zone;
206 if (i)
207 i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)), zone);
208 return i;
209 }
210 zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
211 i = inode->u.xiafs_i.i_dind_zone;
212 if (i)
213 i = zone_bmap(bread(inode->i_dev, i, XIAFS_ZSIZE(inode->i_sb)),
214 zone >> XIAFS_ADDRS_PER_Z_BITS(inode->i_sb));
215 if (i)
216 i= zone_bmap(bread(inode->i_dev,i, XIAFS_ZSIZE(inode->i_sb)),
217 zone & (XIAFS_ADDRS_PER_Z(inode->i_sb)-1));
218 return i;
219 }
220
221 static u_long get_prev_addr(struct inode * inode, int zone)
222 {
223 u_long tmp;
224
225 if (zone > 0)
226 while (--zone >= 0)
227 if ((tmp=xiafs_bmap(inode, zone)))
228 return tmp;
229 random_nr=(random_nr+23)%inode->i_sb->u.xiafs_sb.s_ndatazones;
230 return random_nr + inode->i_sb->u.xiafs_sb.s_firstdatazone;
231 }
232
233 static struct buffer_head *
234 dt_getblk(struct inode * inode, u_long *lp, int create, u_long prev_addr)
235 {
236 int tmp;
237 struct buffer_head * result;
238
239 repeat:
240 if ((tmp=*lp)) {
241 result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
242 if (tmp == *lp)
243 return result;
244 brelse(result);
245 goto repeat;
246 }
247 if (!create)
248 return NULL;
249 tmp = xiafs_new_zone(inode->i_sb, prev_addr);
250 if (!tmp)
251 return NULL;
252 result = getblk(inode->i_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
253 if (*lp) {
254 xiafs_free_zone(inode->i_sb, tmp);
255 brelse(result);
256 goto repeat;
257 }
258 *lp = tmp;
259 inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
260 return result;
261 }
262
263 static struct buffer_head *
264 indt_getblk(struct inode * inode, struct buffer_head * bh,
265 int nr, int create, u_long prev_addr)
266 {
267 int tmp;
268 u_long *lp;
269 struct buffer_head * result;
270
271 if (!bh)
272 return NULL;
273 if (!bh->b_uptodate) {
274 ll_rw_block(READ, 1, &bh);
275 wait_on_buffer(bh);
276 if (!bh->b_uptodate) {
277 brelse(bh);
278 return NULL;
279 }
280 }
281 lp = nr + (u_long *) bh->b_data;
282 repeat:
283 if ((tmp=*lp)) {
284 result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
285 if (tmp == *lp) {
286 brelse(bh);
287 return result;
288 }
289 brelse(result);
290 goto repeat;
291 }
292 if (!create) {
293 brelse(bh);
294 return NULL;
295 }
296 tmp = xiafs_new_zone(inode->i_sb, prev_addr);
297 if (!tmp) {
298 brelse(bh);
299 return NULL;
300 }
301 result = getblk(bh->b_dev, tmp, XIAFS_ZSIZE(inode->i_sb));
302 if (*lp) {
303 xiafs_free_zone(inode->i_sb, tmp);
304 brelse(result);
305 goto repeat;
306 }
307 *lp = tmp;
308 inode->i_blocks+=2 << XIAFS_ZSHIFT(inode->i_sb);
309 mark_buffer_dirty(bh, 1);
310 brelse(bh);
311 return result;
312 }
313
314 struct buffer_head * xiafs_getblk(struct inode * inode, int zone, int create)
315 {
316 struct buffer_head * bh;
317 u_long prev_addr=0;
318
319 if (zone<0) {
320 printk("XIA-FS: zone < 0 (%s %d)\n", WHERE_ERR);
321 return NULL;
322 }
323 if (zone >= 8+(1+XIAFS_ADDRS_PER_Z(inode->i_sb))*XIAFS_ADDRS_PER_Z(inode->i_sb)) {
324 if (!create)
325 printk("XIA-FS: zone > big (%s %d)\n", WHERE_ERR);
326 return NULL;
327 }
328 if (create)
329 prev_addr=get_prev_addr(inode, zone);
330 if (zone < 8)
331 return dt_getblk(inode, zone+inode->u.xiafs_i.i_zone, create, prev_addr);
332 zone -= 8;
333 if (zone < XIAFS_ADDRS_PER_Z(inode->i_sb)) {
334 bh = dt_getblk(inode, &(inode->u.xiafs_i.i_ind_zone), create, prev_addr);
335 bh = indt_getblk(inode, bh, zone, create, prev_addr);
336 return bh;
337 }
338 zone -= XIAFS_ADDRS_PER_Z(inode->i_sb);
339 bh = dt_getblk(inode, &(inode->u.xiafs_i.i_dind_zone), create, prev_addr);
340 bh = indt_getblk(inode, bh, zone>>XIAFS_ADDRS_PER_Z_BITS(inode->i_sb),
341 create, prev_addr);
342 bh = indt_getblk(inode, bh, zone&(XIAFS_ADDRS_PER_Z(inode->i_sb)-1),
343 create, prev_addr);
344 return bh;
345 }
346
347 struct buffer_head * xiafs_bread(struct inode * inode, int zone, int create)
348 {
349 struct buffer_head * bh;
350
351 bh = xiafs_getblk(inode, zone, create);
352 if (!bh || bh->b_uptodate)
353 return bh;
354 ll_rw_block(READ, 1, &bh);
355 wait_on_buffer(bh);
356 if (bh->b_uptodate)
357 return bh;
358 brelse(bh);
359 return NULL;
360 }
361
362 void xiafs_read_inode(struct inode * inode)
363 {
364 struct buffer_head * bh;
365 struct xiafs_inode * raw_inode;
366 int zone;
367 ino_t ino;
368
369 ino = inode->i_ino;
370 inode->i_op = NULL;
371 inode->i_mode=0;
372 if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
373 printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
374 return;
375 }
376 zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
377 inode->i_sb->u.xiafs_sb.s_zmap_zones +
378 (ino-1)/ XIAFS_INODES_PER_Z(inode->i_sb);
379 if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
380 printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
381 return;
382 }
383 raw_inode = ((struct xiafs_inode *) bh->b_data) +
384 ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) - 1));
385 inode->i_mode = raw_inode->i_mode;
386 inode->i_uid = raw_inode->i_uid;
387 inode->i_gid = raw_inode->i_gid;
388 inode->i_nlink = raw_inode->i_nlinks;
389 inode->i_size = raw_inode->i_size;
390 inode->i_mtime = raw_inode->i_mtime;
391 inode->i_atime = raw_inode->i_atime;
392 inode->i_ctime = raw_inode->i_ctime;
393 inode->i_blksize = XIAFS_ZSIZE(inode->i_sb);
394 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
395 inode->i_blocks=0;
396 inode->i_rdev = raw_inode->i_zone[0];
397 } else {
398 XIAFS_GET_BLOCKS(raw_inode, inode->i_blocks);
399 for (zone = 0; zone < 8; zone++)
400 inode->u.xiafs_i.i_zone[zone] = raw_inode->i_zone[zone] & 0xffffff;
401 inode->u.xiafs_i.i_ind_zone = raw_inode->i_ind_zone & 0xffffff;
402 inode->u.xiafs_i.i_dind_zone = raw_inode->i_dind_zone & 0xffffff;
403 }
404 brelse(bh);
405 if (S_ISREG(inode->i_mode))
406 inode->i_op = &xiafs_file_inode_operations;
407 else if (S_ISDIR(inode->i_mode))
408 inode->i_op = &xiafs_dir_inode_operations;
409 else if (S_ISLNK(inode->i_mode))
410 inode->i_op = &xiafs_symlink_inode_operations;
411 else if (S_ISCHR(inode->i_mode))
412 inode->i_op = &chrdev_inode_operations;
413 else if (S_ISBLK(inode->i_mode))
414 inode->i_op = &blkdev_inode_operations;
415 else if (S_ISFIFO(inode->i_mode))
416 init_fifo(inode);
417 }
418
419 static struct buffer_head * xiafs_update_inode(struct inode * inode)
420 {
421 struct buffer_head * bh;
422 struct xiafs_inode * raw_inode;
423 int zone;
424 ino_t ino;
425
426 if (IS_RDONLY (inode)) {
427 printk("XIA-FS: write_inode on a read-only filesystem (%s %d)\n", WHERE_ERR);
428 inode->i_dirt = 0;
429 return 0;
430 }
431
432 ino = inode->i_ino;
433 if (!ino || ino > inode->i_sb->u.xiafs_sb.s_ninodes) {
434 printk("XIA-FS: bad inode number (%s %d)\n", WHERE_ERR);
435 inode->i_dirt=0;
436 return 0;
437 }
438 zone = 1 + inode->i_sb->u.xiafs_sb.s_imap_zones +
439 inode->i_sb->u.xiafs_sb.s_zmap_zones +
440 (ino-1) / XIAFS_INODES_PER_Z(inode->i_sb);
441 if (!(bh=bread(inode->i_dev, zone, XIAFS_ZSIZE(inode->i_sb)))) {
442 printk("XIA-FS: read i-node zone failed (%s %d)\n", WHERE_ERR);
443 inode->i_dirt=0;
444 return 0;
445 }
446 raw_inode = ((struct xiafs_inode *)bh->b_data) +
447 ((ino-1) & (XIAFS_INODES_PER_Z(inode->i_sb) -1));
448 raw_inode->i_mode = inode->i_mode;
449 raw_inode->i_uid = inode->i_uid;
450 raw_inode->i_gid = inode->i_gid;
451 raw_inode->i_nlinks = inode->i_nlink;
452 raw_inode->i_size = inode->i_size;
453 raw_inode->i_atime = inode->i_atime;
454 raw_inode->i_ctime = inode->i_ctime;
455 raw_inode->i_mtime = inode->i_mtime;
456 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode))
457 raw_inode->i_zone[0] = inode->i_rdev;
458 else {
459 XIAFS_PUT_BLOCKS(raw_inode, inode->i_blocks);
460 for (zone = 0; zone < 8; zone++)
461 raw_inode->i_zone[zone] = (raw_inode->i_zone[zone] & 0xff000000)
462 | (inode->u.xiafs_i.i_zone[zone] & 0xffffff);
463 raw_inode->i_ind_zone = (raw_inode->i_ind_zone & 0xff000000)
464 | (inode->u.xiafs_i.i_ind_zone & 0xffffff);
465 raw_inode->i_dind_zone = (raw_inode->i_dind_zone & 0xff000000)
466 | (inode->u.xiafs_i.i_dind_zone & 0xffffff);
467 }
468 inode->i_dirt=0;
469 mark_buffer_dirty(bh, 1);
470 return bh;
471 }
472
473
474 void xiafs_write_inode(struct inode * inode)
475 {
476 struct buffer_head * bh;
477 bh = xiafs_update_inode(inode);
478 brelse (bh);
479 }
480
481 int xiafs_sync_inode (struct inode *inode)
482 {
483 int err = 0;
484 struct buffer_head *bh;
485
486 bh = xiafs_update_inode(inode);
487 if (bh && bh->b_dirt)
488 {
489 ll_rw_block(WRITE, 1, &bh);
490 wait_on_buffer(bh);
491 if (bh->b_req && !bh->b_uptodate)
492 {
493 printk ("IO error syncing xiafs inode [%04X:%lu]\n",
494 inode->i_dev, inode->i_ino);
495 err = -1;
496 }
497 }
498 else if (!bh)
499 err = -1;
500 brelse (bh);
501 return err;
502 }
![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
![[previous]](../icons/left.png)
![[last]](../icons/n_last.png)
![[bottom]](../icons/n_bottom.png){kind=icon}