[PATCH] ufs: directory and page cache: from blocks to pages
[linux-2.6.git] / fs / ufs / util.h
1 /*
2  *  linux/fs/ufs/util.h
3  *
4  * Copyright (C) 1998 
5  * Daniel Pirkl <daniel.pirkl@email.cz>
6  * Charles University, Faculty of Mathematics and Physics
7  */
8
9 #include <linux/buffer_head.h>
10 #include <linux/fs.h>
11 #include "swab.h"
12
13
14 /*
15  * some useful macros
16  */
17 #define in_range(b,first,len)   ((b)>=(first)&&(b)<(first)+(len))
18
19 /*
20  * macros used for retyping
21  */
22 #define UCPI_UBH ((struct ufs_buffer_head *)ucpi)
23 #define USPI_UBH ((struct ufs_buffer_head *)uspi)
24
25
26
27 /*
28  * macros used for accessing structures
29  */
30 static inline s32
31 ufs_get_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
32                  struct ufs_super_block_third *usb3)
33 {
34         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
35         case UFS_ST_SUN:
36                 return fs32_to_cpu(sb, usb3->fs_u2.fs_sun.fs_state);
37         case UFS_ST_SUNx86:
38                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sunx86.fs_state);
39         case UFS_ST_44BSD:
40         default:
41                 return fs32_to_cpu(sb, usb3->fs_u2.fs_44.fs_state);
42         }
43 }
44
45 static inline void
46 ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
47                  struct ufs_super_block_third *usb3, s32 value)
48 {
49         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
50         case UFS_ST_SUN:
51                 usb3->fs_u2.fs_sun.fs_state = cpu_to_fs32(sb, value);
52                 break;
53         case UFS_ST_SUNx86:
54                 usb1->fs_u1.fs_sunx86.fs_state = cpu_to_fs32(sb, value);
55                 break;
56         case UFS_ST_44BSD:
57                 usb3->fs_u2.fs_44.fs_state = cpu_to_fs32(sb, value);
58                 break;
59         }
60 }
61
62 static inline u32
63 ufs_get_fs_npsect(struct super_block *sb, struct ufs_super_block_first *usb1,
64                   struct ufs_super_block_third *usb3)
65 {
66         if ((UFS_SB(sb)->s_flags & UFS_ST_MASK) == UFS_ST_SUNx86)
67                 return fs32_to_cpu(sb, usb3->fs_u2.fs_sunx86.fs_npsect);
68         else
69                 return fs32_to_cpu(sb, usb1->fs_u1.fs_sun.fs_npsect);
70 }
71
72 static inline u64
73 ufs_get_fs_qbmask(struct super_block *sb, struct ufs_super_block_third *usb3)
74 {
75         __fs64 tmp;
76
77         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
78         case UFS_ST_SUN:
79                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qbmask[0];
80                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qbmask[1];
81                 break;
82         case UFS_ST_SUNx86:
83                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qbmask[0];
84                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qbmask[1];
85                 break;
86         case UFS_ST_44BSD:
87                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qbmask[0];
88                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qbmask[1];
89                 break;
90         }
91
92         return fs64_to_cpu(sb, tmp);
93 }
94
95 static inline u64
96 ufs_get_fs_qfmask(struct super_block *sb, struct ufs_super_block_third *usb3)
97 {
98         __fs64 tmp;
99
100         switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
101         case UFS_ST_SUN:
102                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sun.fs_qfmask[0];
103                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sun.fs_qfmask[1];
104                 break;
105         case UFS_ST_SUNx86:
106                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_sunx86.fs_qfmask[0];
107                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_sunx86.fs_qfmask[1];
108                 break;
109         case UFS_ST_44BSD:
110                 ((__fs32 *)&tmp)[0] = usb3->fs_u2.fs_44.fs_qfmask[0];
111                 ((__fs32 *)&tmp)[1] = usb3->fs_u2.fs_44.fs_qfmask[1];
112                 break;
113         }
114
115         return fs64_to_cpu(sb, tmp);
116 }
117
118 static inline u16
119 ufs_get_de_namlen(struct super_block *sb, struct ufs_dir_entry *de)
120 {
121         if ((UFS_SB(sb)->s_flags & UFS_DE_MASK) == UFS_DE_OLD)
122                 return fs16_to_cpu(sb, de->d_u.d_namlen);
123         else
124                 return de->d_u.d_44.d_namlen; /* XXX this seems wrong */
125 }
126
127 static inline void
128 ufs_set_de_namlen(struct super_block *sb, struct ufs_dir_entry *de, u16 value)
129 {
130         if ((UFS_SB(sb)->s_flags & UFS_DE_MASK) == UFS_DE_OLD)
131                 de->d_u.d_namlen = cpu_to_fs16(sb, value);
132         else
133                 de->d_u.d_44.d_namlen = value; /* XXX this seems wrong */
134 }
135
136 static inline void
137 ufs_set_de_type(struct super_block *sb, struct ufs_dir_entry *de, int mode)
138 {
139         if ((UFS_SB(sb)->s_flags & UFS_DE_MASK) != UFS_DE_44BSD)
140                 return;
141
142         /*
143          * TODO turn this into a table lookup
144          */
145         switch (mode & S_IFMT) {
146         case S_IFSOCK:
147                 de->d_u.d_44.d_type = DT_SOCK;
148                 break;
149         case S_IFLNK:
150                 de->d_u.d_44.d_type = DT_LNK;
151                 break;
152         case S_IFREG:
153                 de->d_u.d_44.d_type = DT_REG;
154                 break;
155         case S_IFBLK:
156                 de->d_u.d_44.d_type = DT_BLK;
157                 break;
158         case S_IFDIR:
159                 de->d_u.d_44.d_type = DT_DIR;
160                 break;
161         case S_IFCHR:
162                 de->d_u.d_44.d_type = DT_CHR;
163                 break;
164         case S_IFIFO:
165                 de->d_u.d_44.d_type = DT_FIFO;
166                 break;
167         default:
168                 de->d_u.d_44.d_type = DT_UNKNOWN;
169         }
170 }
171
172 static inline u32
173 ufs_get_inode_uid(struct super_block *sb, struct ufs_inode *inode)
174 {
175         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
176         case UFS_UID_EFT:
177                 return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_uid);
178         case UFS_UID_44BSD:
179                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_uid);
180         default:
181                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_suid);
182         }
183 }
184
185 static inline void
186 ufs_set_inode_uid(struct super_block *sb, struct ufs_inode *inode, u32 value)
187 {
188         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
189         case UFS_UID_EFT:
190                 inode->ui_u3.ui_sun.ui_uid = cpu_to_fs32(sb, value);
191                 break;
192         case UFS_UID_44BSD:
193                 inode->ui_u3.ui_44.ui_uid = cpu_to_fs32(sb, value);
194                 break;
195         }
196         inode->ui_u1.oldids.ui_suid = cpu_to_fs16(sb, value); 
197 }
198
199 static inline u32
200 ufs_get_inode_gid(struct super_block *sb, struct ufs_inode *inode)
201 {
202         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
203         case UFS_UID_EFT:
204                 return fs32_to_cpu(sb, inode->ui_u3.ui_sun.ui_gid);
205         case UFS_UID_44BSD:
206                 return fs32_to_cpu(sb, inode->ui_u3.ui_44.ui_gid);
207         default:
208                 return fs16_to_cpu(sb, inode->ui_u1.oldids.ui_sgid);
209         }
210 }
211
212 static inline void
213 ufs_set_inode_gid(struct super_block *sb, struct ufs_inode *inode, u32 value)
214 {
215         switch (UFS_SB(sb)->s_flags & UFS_UID_MASK) {
216         case UFS_UID_EFT:
217                 inode->ui_u3.ui_sun.ui_gid = cpu_to_fs32(sb, value);
218                 break;
219         case UFS_UID_44BSD:
220                 inode->ui_u3.ui_44.ui_gid = cpu_to_fs32(sb, value);
221                 break;
222         }
223         inode->ui_u1.oldids.ui_sgid =  cpu_to_fs16(sb, value);
224 }
225
226 extern dev_t ufs_get_inode_dev(struct super_block *, struct ufs_inode_info *);
227 extern void ufs_set_inode_dev(struct super_block *, struct ufs_inode_info *, dev_t);
228
229 /*
230  * These functions manipulate ufs buffers
231  */
232 #define ubh_bread(sb,fragment,size) _ubh_bread_(uspi,sb,fragment,size)  
233 extern struct ufs_buffer_head * _ubh_bread_(struct ufs_sb_private_info *, struct super_block *, u64 , u64);
234 extern struct ufs_buffer_head * ubh_bread_uspi(struct ufs_sb_private_info *, struct super_block *, u64, u64);
235 extern void ubh_brelse (struct ufs_buffer_head *);
236 extern void ubh_brelse_uspi (struct ufs_sb_private_info *);
237 extern void ubh_mark_buffer_dirty (struct ufs_buffer_head *);
238 extern void ubh_mark_buffer_uptodate (struct ufs_buffer_head *, int);
239 extern void ubh_ll_rw_block (int, unsigned, struct ufs_buffer_head **);
240 extern void ubh_wait_on_buffer (struct ufs_buffer_head *);
241 extern void ubh_bforget (struct ufs_buffer_head *);
242 extern int  ubh_buffer_dirty (struct ufs_buffer_head *);
243 #define ubh_ubhcpymem(mem,ubh,size) _ubh_ubhcpymem_(uspi,mem,ubh,size)
244 extern void _ubh_ubhcpymem_(struct ufs_sb_private_info *, unsigned char *, struct ufs_buffer_head *, unsigned);
245 #define ubh_memcpyubh(ubh,mem,size) _ubh_memcpyubh_(uspi,ubh,mem,size)
246 extern void _ubh_memcpyubh_(struct ufs_sb_private_info *, struct ufs_buffer_head *, unsigned char *, unsigned);
247
248
249
250 /*
251  * macros and inline function to get important structures from ufs_sb_private_info
252  */
253
254 static inline void *get_usb_offset(struct ufs_sb_private_info *uspi,
255                                    unsigned int offset)
256 {
257         unsigned int index;
258         
259         index = offset >> uspi->s_fshift;
260         offset &= ~uspi->s_fmask;
261         return uspi->s_ubh.bh[index]->b_data + offset;
262 }
263
264 #define ubh_get_usb_first(uspi) \
265         ((struct ufs_super_block_first *)get_usb_offset((uspi), 0))
266
267 #define ubh_get_usb_second(uspi) \
268         ((struct ufs_super_block_second *)get_usb_offset((uspi), UFS_SECTOR_SIZE))
269
270 #define ubh_get_usb_third(uspi) \
271         ((struct ufs_super_block_third *)get_usb_offset((uspi), 2*UFS_SECTOR_SIZE))
272
273
274 #define ubh_get_ucg(ubh) \
275         ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))
276
277
278 /*
279  * Extract byte from ufs_buffer_head
280  * Extract the bits for a block from a map inside ufs_buffer_head
281  */
282 #define ubh_get_addr8(ubh,begin) \
283         ((u8*)(ubh)->bh[(begin) >> uspi->s_fshift]->b_data + \
284         ((begin) & ~uspi->s_fmask))
285
286 #define ubh_get_addr16(ubh,begin) \
287         (((__fs16*)((ubh)->bh[(begin) >> (uspi->s_fshift-1)]->b_data)) + \
288         ((begin) & (uspi->fsize>>1) - 1)))
289
290 #define ubh_get_addr32(ubh,begin) \
291         (((__fs32*)((ubh)->bh[(begin) >> (uspi->s_fshift-2)]->b_data)) + \
292         ((begin) & ((uspi->s_fsize>>2) - 1)))
293
294 #define ubh_get_addr ubh_get_addr8
295
296 #define ubh_blkmap(ubh,begin,bit) \
297         ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
298
299
300 /*
301  * Macros for access to superblock array structures
302  */
303 #define ubh_postbl(ubh,cylno,i) \
304         ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
305         ? (*(__s16*)(ubh_get_addr(ubh, \
306         (unsigned)(&((struct ufs_super_block *)0)->fs_opostbl) \
307         + (((cylno) * 16 + (i)) << 1) ) )) \
308         : (*(__s16*)(ubh_get_addr(ubh, \
309         uspi->s_postbloff + (((cylno) * uspi->s_nrpos + (i)) << 1) ))))
310
311 #define ubh_rotbl(ubh,i) \
312         ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
313         ? (*(__u8*)(ubh_get_addr(ubh, \
314         (unsigned)(&((struct ufs_super_block *)0)->fs_space) + (i)))) \
315         : (*(__u8*)(ubh_get_addr(ubh, uspi->s_rotbloff + (i)))))
316
317 /*
318  * Determine the number of available frags given a
319  * percentage to hold in reserve.
320  */
321 #define ufs_freespace(usb, percentreserved) \
322         (ufs_blkstofrags(fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nbfree)) + \
323         fs32_to_cpu(sb, (usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
324
325 /*
326  * Macros to access cylinder group array structures
327  */
328 #define ubh_cg_blktot(ucpi,cylno) \
329         (*((__fs32*)ubh_get_addr(UCPI_UBH, (ucpi)->c_btotoff + ((cylno) << 2))))
330
331 #define ubh_cg_blks(ucpi,cylno,rpos) \
332         (*((__fs16*)ubh_get_addr(UCPI_UBH, \
333         (ucpi)->c_boff + (((cylno) * uspi->s_nrpos + (rpos)) << 1 ))))
334
335 /*
336  * Bitmap operations
337  * These functions work like classical bitmap operations.
338  * The difference is that we don't have the whole bitmap
339  * in one contiguous chunk of memory, but in several buffers.
340  * The parameters of each function are super_block, ufs_buffer_head and
341  * position of the beginning of the bitmap.
342  */
343 #define ubh_setbit(ubh,begin,bit) \
344         (*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) |= (1 << ((bit) & 7)))
345
346 #define ubh_clrbit(ubh,begin,bit) \
347         (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) &= ~(1 << ((bit) & 7)))
348
349 #define ubh_isset(ubh,begin,bit) \
350         (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) & (1 << ((bit) & 7)))
351
352 #define ubh_isclr(ubh,begin,bit) (!ubh_isset(ubh,begin,bit))
353
354 #define ubh_find_first_zero_bit(ubh,begin,size) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,0)
355
356 #define ubh_find_next_zero_bit(ubh,begin,size,offset) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,offset)
357 static inline unsigned _ubh_find_next_zero_bit_(
358         struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh,
359         unsigned begin, unsigned size, unsigned offset)
360 {
361         unsigned base, count, pos;
362
363         size -= offset;
364         begin <<= 3;
365         offset += begin;
366         base = offset >> uspi->s_bpfshift;
367         offset &= uspi->s_bpfmask;
368         for (;;) {
369                 count = min_t(unsigned int, size + offset, uspi->s_bpf);
370                 size -= count - offset;
371                 pos = ext2_find_next_zero_bit (ubh->bh[base]->b_data, count, offset);
372                 if (pos < count || !size)
373                         break;
374                 base++;
375                 offset = 0;
376         }
377         return (base << uspi->s_bpfshift) + pos - begin;
378 }       
379
380 static inline unsigned find_last_zero_bit (unsigned char * bitmap,
381         unsigned size, unsigned offset)
382 {
383         unsigned bit, i;
384         unsigned char * mapp;
385         unsigned char map;
386
387         mapp = bitmap + (size >> 3);
388         map = *mapp--;
389         bit = 1 << (size & 7);
390         for (i = size; i > offset; i--) {
391                 if ((map & bit) == 0)
392                         break;
393                 if ((i & 7) != 0) {
394                         bit >>= 1;
395                 } else {
396                         map = *mapp--;
397                         bit = 1 << 7;
398                 }
399         }
400         return i;
401 }
402
403 #define ubh_find_last_zero_bit(ubh,begin,size,offset) _ubh_find_last_zero_bit_(uspi,ubh,begin,size,offset)
404 static inline unsigned _ubh_find_last_zero_bit_(
405         struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh,
406         unsigned begin, unsigned start, unsigned end)
407 {
408         unsigned base, count, pos, size;
409
410         size = start - end;
411         begin <<= 3;
412         start += begin;
413         base = start >> uspi->s_bpfshift;
414         start &= uspi->s_bpfmask;
415         for (;;) {
416                 count = min_t(unsigned int,
417                             size + (uspi->s_bpf - start), uspi->s_bpf)
418                         - (uspi->s_bpf - start);
419                 size -= count;
420                 pos = find_last_zero_bit (ubh->bh[base]->b_data,
421                         start, start - count);
422                 if (pos > start - count || !size)
423                         break;
424                 base--;
425                 start = uspi->s_bpf;
426         }
427         return (base << uspi->s_bpfshift) + pos - begin;
428 }       
429
430 #define ubh_isblockclear(ubh,begin,block) (!_ubh_isblockset_(uspi,ubh,begin,block))
431
432 #define ubh_isblockset(ubh,begin,block) _ubh_isblockset_(uspi,ubh,begin,block)
433 static inline int _ubh_isblockset_(struct ufs_sb_private_info * uspi,
434         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
435 {
436         switch (uspi->s_fpb) {
437         case 8:
438                 return (*ubh_get_addr (ubh, begin + block) == 0xff);
439         case 4:
440                 return (*ubh_get_addr (ubh, begin + (block >> 1)) == (0x0f << ((block & 0x01) << 2)));
441         case 2:
442                 return (*ubh_get_addr (ubh, begin + (block >> 2)) == (0x03 << ((block & 0x03) << 1)));
443         case 1:
444                 return (*ubh_get_addr (ubh, begin + (block >> 3)) == (0x01 << (block & 0x07)));
445         }
446         return 0;       
447 }
448
449 #define ubh_clrblock(ubh,begin,block) _ubh_clrblock_(uspi,ubh,begin,block)
450 static inline void _ubh_clrblock_(struct ufs_sb_private_info * uspi,
451         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
452 {
453         switch (uspi->s_fpb) {
454         case 8:
455                 *ubh_get_addr (ubh, begin + block) = 0x00;
456                 return; 
457         case 4:
458                 *ubh_get_addr (ubh, begin + (block >> 1)) &= ~(0x0f << ((block & 0x01) << 2));
459                 return;
460         case 2:
461                 *ubh_get_addr (ubh, begin + (block >> 2)) &= ~(0x03 << ((block & 0x03) << 1));
462                 return;
463         case 1:
464                 *ubh_get_addr (ubh, begin + (block >> 3)) &= ~(0x01 << ((block & 0x07)));
465                 return;
466         }
467 }
468
469 #define ubh_setblock(ubh,begin,block) _ubh_setblock_(uspi,ubh,begin,block)
470 static inline void _ubh_setblock_(struct ufs_sb_private_info * uspi,
471         struct ufs_buffer_head * ubh, unsigned begin, unsigned block)
472 {
473         switch (uspi->s_fpb) {
474         case 8:
475                 *ubh_get_addr(ubh, begin + block) = 0xff;
476                 return;
477         case 4:
478                 *ubh_get_addr(ubh, begin + (block >> 1)) |= (0x0f << ((block & 0x01) << 2));
479                 return;
480         case 2:
481                 *ubh_get_addr(ubh, begin + (block >> 2)) |= (0x03 << ((block & 0x03) << 1));
482                 return;
483         case 1:
484                 *ubh_get_addr(ubh, begin + (block >> 3)) |= (0x01 << ((block & 0x07)));
485                 return;
486         }
487 }
488
489 static inline void ufs_fragacct (struct super_block * sb, unsigned blockmap,
490         __fs32 * fraglist, int cnt)
491 {
492         struct ufs_sb_private_info * uspi;
493         unsigned fragsize, pos;
494         
495         uspi = UFS_SB(sb)->s_uspi;
496         
497         fragsize = 0;
498         for (pos = 0; pos < uspi->s_fpb; pos++) {
499                 if (blockmap & (1 << pos)) {
500                         fragsize++;
501                 }
502                 else if (fragsize > 0) {
503                         fs32_add(sb, &fraglist[fragsize], cnt);
504                         fragsize = 0;
505                 }
506         }
507         if (fragsize > 0 && fragsize < uspi->s_fpb)
508                 fs32_add(sb, &fraglist[fragsize], cnt);
509 }
510
511 #define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
512 static inline unsigned _ubh_scanc_(struct ufs_sb_private_info * uspi, struct ufs_buffer_head * ubh, 
513         unsigned begin, unsigned size, unsigned char * table, unsigned char mask)
514 {
515         unsigned rest, offset;
516         unsigned char * cp;
517         
518
519         offset = begin & ~uspi->s_fmask;
520         begin >>= uspi->s_fshift;
521         for (;;) {
522                 if ((offset + size) < uspi->s_fsize)
523                         rest = size;
524                 else
525                         rest = uspi->s_fsize - offset;
526                 size -= rest;
527                 cp = ubh->bh[begin]->b_data + offset;
528                 while ((table[*cp++] & mask) == 0 && --rest);
529                 if (rest || !size)
530                         break;
531                 begin++;
532                 offset = 0;
533         }
534         return (size + rest);
535 }