5 * Daniel Pirkl <daniel.pirkl@email.cz>
6 * Charles University, Faculty of Mathematics and Physics
16 #define in_range(b,first,len) ((b)>=(first)&&(b)<(first)+(len))
17 #define howmany(x,y) (((x)+(y)-1)/(y))
18 #define min(x,y) ((x)<(y)?(x):(y))
19 #define max(x,y) ((x)>(y)?(x):(y))
24 * macros used for retyping
26 #define UCPI_UBH ((struct ufs_buffer_head *)ucpi)
27 #define USPI_UBH ((struct ufs_buffer_head *)uspi)
32 * macros used for accesing structures
34 #define ufs_get_fs_state(usb3) _ufs_get_fs_state_(usb3,flags,swab)
35 static inline __s32
_ufs_get_fs_state_(struct ufs_super_block_third
* usb3
,
36 unsigned flags
, unsigned swab
)
38 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
)
39 return SWAB32((usb3
)->fs_u
.fs_sun
.fs_state
);
41 return SWAB32((usb3
)->fs_u
.fs_44
.fs_state
);
44 #define ufs_set_fs_state(usb3,value) _ufs_set_fs_state_(usb3,value,flags,swab)
45 static inline void _ufs_set_fs_state_(struct ufs_super_block_third
* usb3
,
46 __s32 value
, unsigned flags
, unsigned swab
)
48 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
)
49 (usb3
)->fs_u
.fs_sun
.fs_state
= SWAB32(value
);
51 (usb3
)->fs_u
.fs_44
.fs_state
= SWAB32(value
);
54 #define ufs_get_fs_qbmask(usb3) _ufs_get_fs_qbmask_(usb3,flags,swab)
55 static inline __u64
_ufs_get_fs_qbmask_(struct ufs_super_block_third
* usb3
,
56 unsigned flags
, unsigned swab
)
59 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
) {
60 ((u32
*)&tmp
)[0] = usb3
->fs_u
.fs_sun
.fs_qbmask
[0];
61 ((u32
*)&tmp
)[1] = usb3
->fs_u
.fs_sun
.fs_qbmask
[1];
64 ((u32
*)&tmp
)[0] = usb3
->fs_u
.fs_44
.fs_qbmask
[0];
65 ((u32
*)&tmp
)[1] = usb3
->fs_u
.fs_44
.fs_qbmask
[1];
70 #define ufs_get_fs_qfmask(usb3) _ufs_get_fs_qfmask_(usb3,flags,swab)
71 static inline __u64
_ufs_get_fs_qfmask_(struct ufs_super_block_third
* usb3
,
72 unsigned flags
, unsigned swab
)
75 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUN
) {
76 ((u32
*)&tmp
)[0] = usb3
->fs_u
.fs_sun
.fs_qfmask
[0];
77 ((u32
*)&tmp
)[1] = usb3
->fs_u
.fs_sun
.fs_qfmask
[1];
80 ((u32
*)&tmp
)[0] = usb3
->fs_u
.fs_44
.fs_qfmask
[0];
81 ((u32
*)&tmp
)[1] = usb3
->fs_u
.fs_44
.fs_qfmask
[1];
86 #define ufs_get_de_namlen(de) \
87 (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
88 ? SWAB16(de->d_u.d_namlen) \
89 : de->d_u.d_44.d_namlen)
91 #define ufs_set_de_namlen(de,value) \
92 (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
93 ? (de->d_u.d_namlen = SWAB16(value)) \
94 : (de->d_u.d_44.d_namlen = value))
96 #define ufs_set_de_type(de,mode) _ufs_set_de_type_(de,mode,flags,swab)
97 static inline void _ufs_set_de_type_(struct ufs_dir_entry
* de
, int mode
,
98 unsigned flags
, unsigned swab
)
100 if ((flags
& UFS_DE_MASK
) == UFS_DE_44BSD
) {
101 switch (mode
& S_IFMT
) {
102 case S_IFSOCK
: de
->d_u
.d_44
.d_type
= DT_SOCK
; break;
103 case S_IFLNK
: de
->d_u
.d_44
.d_type
= DT_LNK
; break;
104 case S_IFREG
: de
->d_u
.d_44
.d_type
= DT_REG
; break;
105 case S_IFBLK
: de
->d_u
.d_44
.d_type
= DT_BLK
; break;
106 case S_IFDIR
: de
->d_u
.d_44
.d_type
= DT_DIR
; break;
107 case S_IFCHR
: de
->d_u
.d_44
.d_type
= DT_CHR
; break;
108 case S_IFIFO
: de
->d_u
.d_44
.d_type
= DT_FIFO
; break;
109 default: de
->d_u
.d_44
.d_type
= DT_UNKNOWN
;
114 #define ufs_get_inode_uid(inode) _ufs_get_inode_uid_(inode,flags,swab)
115 static inline __u32
_ufs_get_inode_uid_(struct ufs_inode
* inode
,
116 unsigned flags
, unsigned swab
)
118 switch (flags
& UFS_UID_MASK
) {
120 return SWAB32(inode
->ui_u3
.ui_sun
.ui_uid
);
122 return SWAB32(inode
->ui_u3
.ui_44
.ui_uid
);
124 return SWAB16(inode
->ui_u1
.oldids
.ui_suid
);
128 #define ufs_set_inode_uid(inode,value) _ufs_set_inode_uid_(inode,value,flags,swab)
129 static inline void _ufs_set_inode_uid_(struct ufs_inode
* inode
, __u32 value
,
130 unsigned flags
, unsigned swab
)
132 inode
->ui_u1
.oldids
.ui_suid
= SWAB16(value
);
133 switch (flags
& UFS_UID_MASK
) {
135 inode
->ui_u3
.ui_sun
.ui_uid
= SWAB32(value
);
138 inode
->ui_u3
.ui_44
.ui_uid
= SWAB32(value
);
143 #define ufs_get_inode_gid(inode) _ufs_get_inode_gid_(inode,flags,swab)
144 static inline __u32
_ufs_get_inode_gid_(struct ufs_inode
* inode
,
145 unsigned flags
, unsigned swab
)
147 switch (flags
& UFS_UID_MASK
) {
149 return SWAB32(inode
->ui_u3
.ui_sun
.ui_gid
);
151 return SWAB32(inode
->ui_u3
.ui_44
.ui_gid
);
153 return SWAB16(inode
->ui_u1
.oldids
.ui_sgid
);
157 #define ufs_set_inode_gid(inode,value) _ufs_set_inode_gid_(inode,value,flags,swab)
158 static inline void _ufs_set_inode_gid_(struct ufs_inode
* inode
, __u32 value
,
159 unsigned flags
, unsigned swab
)
161 inode
->ui_u1
.oldids
.ui_sgid
= SWAB16(value
);
162 switch (flags
& UFS_UID_MASK
) {
164 inode
->ui_u3
.ui_sun
.ui_gid
= SWAB32(value
);
167 inode
->ui_u3
.ui_44
.ui_gid
= SWAB32(value
);
175 * These functions manipulate ufs buffers
177 #define ubh_bread(dev,fragment,size) _ubh_bread_(uspi,dev,fragment,size)
178 extern struct ufs_buffer_head
* _ubh_bread_(struct ufs_sb_private_info
*, kdev_t
, unsigned, unsigned);
179 extern struct ufs_buffer_head
* ubh_bread_uspi(struct ufs_sb_private_info
*, kdev_t
, unsigned, unsigned);
180 extern void ubh_brelse (struct ufs_buffer_head
*);
181 extern void ubh_brelse_uspi (struct ufs_sb_private_info
*);
182 extern void ubh_mark_buffer_dirty (struct ufs_buffer_head
*, int);
183 extern void ubh_mark_buffer_uptodate (struct ufs_buffer_head
*, int);
184 extern void ubh_ll_rw_block (int, unsigned, struct ufs_buffer_head
**);
185 extern void ubh_wait_on_buffer (struct ufs_buffer_head
*);
186 extern unsigned ubh_max_bcount (struct ufs_buffer_head
*);
187 extern void ubh_bforget (struct ufs_buffer_head
*);
188 extern int ubh_buffer_dirty (struct ufs_buffer_head
*);
189 #define ubh_ubhcpymem(mem,ubh,size) _ubh_ubhcpymem_(uspi,mem,ubh,size)
190 extern void _ubh_ubhcpymem_(struct ufs_sb_private_info
*, unsigned char *, struct ufs_buffer_head
*, unsigned);
191 #define ubh_memcpyubh(ubh,mem,size) _ubh_memcpyubh_(uspi,ubh,mem,size)
192 extern void _ubh_memcpyubh_(struct ufs_sb_private_info
*, struct ufs_buffer_head
*, unsigned char *, unsigned);
197 * macros to get important structures from ufs_buffer_head
199 #define ubh_get_usb_first(ubh) \
200 ((struct ufs_super_block_first *)((ubh)->bh[0]->b_data))
202 #define ubh_get_usb_second(ubh) \
203 ((struct ufs_super_block_second *)(ubh)-> \
204 bh[UFS_SECTOR_SIZE >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE & ~uspi->s_fmask))
206 #define ubh_get_usb_third(ubh) \
207 ((struct ufs_super_block_third *)((ubh)-> \
208 bh[UFS_SECTOR_SIZE*2 >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE*2 & ~uspi->s_fmask)))
210 #define ubh_get_ucg(ubh) \
211 ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))
215 * Extract byte from ufs_buffer_head
216 * Extract the bits for a block from a map inside ufs_buffer_head
218 #define ubh_get_addr8(ubh,begin) \
219 ((u8*)(ubh)->bh[(begin) >> uspi->s_fshift]->b_data + \
220 ((begin) & ~uspi->s_fmask))
222 #define ubh_get_addr16(ubh,begin) \
223 (((u16*)((ubh)->bh[(begin) >> (uspi->s_fshift-1)]->b_data)) + \
224 ((begin) & (uspi->fsize>>1) - 1)))
226 #define ubh_get_addr32(ubh,begin) \
227 (((u32*)((ubh)->bh[(begin) >> (uspi->s_fshift-2)]->b_data)) + \
228 ((begin) & ((uspi->s_fsize>>2) - 1)))
230 #define ubh_get_addr ubh_get_addr8
232 #define ubh_blkmap(ubh,begin,bit) \
233 ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
237 * Macros for access to superblock array structures
239 #define ubh_postbl(ubh,cylno,i) \
240 ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
241 ? (*(__s16*)(ubh_get_addr(ubh, \
242 (unsigned)(&((struct ufs_super_block *)0)->fs_opostbl) \
243 + (((cylno) * 16 + (i)) << 1) ) )) \
244 : (*(__s16*)(ubh_get_addr(ubh, \
245 uspi->s_postbloff + (((cylno) * uspi->s_nrpos + (i)) << 1) ))))
247 #define ubh_rotbl(ubh,i) \
248 ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
249 ? (*(__u8*)(ubh_get_addr(ubh, \
250 (unsigned)(&((struct ufs_super_block *)0)->fs_space) + (i)))) \
251 : (*(__u8*)(ubh_get_addr(ubh, uspi->s_rotbloff + (i)))))
254 * Determine the number of available frags given a
255 * percentage to hold in reserve.
257 #define ufs_freespace(usb, percentreserved) \
258 (ufs_blkstofrags(SWAB32((usb)->fs_cstotal.cs_nbfree)) + \
259 SWAB32((usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
262 * Macros to access cylinder group array structures
264 #define ubh_cg_blktot(ucpi,cylno) \
265 (*((__u32*)ubh_get_addr(UCPI_UBH, (ucpi)->c_btotoff + ((cylno) << 2))))
267 #define ubh_cg_blks(ucpi,cylno,rpos) \
268 (*((__u16*)ubh_get_addr(UCPI_UBH, \
269 (ucpi)->c_boff + (((cylno) * uspi->s_nrpos + (rpos)) << 1 ))))
273 * These functions work like classical bitmap operations.
274 * The difference is that we don't have the whole bitmap
275 * in one contiguous chunk of memory, but in several buffers.
276 * The parameters of each function are super_block, ufs_buffer_head and
277 * position of the beginning of the bitmap.
279 #define ubh_setbit(ubh,begin,bit) \
280 (*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) |= (1 << ((bit) & 7)))
282 #define ubh_clrbit(ubh,begin,bit) \
283 (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) &= ~(1 << ((bit) & 7)))
285 #define ubh_isset(ubh,begin,bit) \
286 (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) & (1 << ((bit) & 7)))
288 #define ubh_isclr(ubh,begin,bit) (!ubh_isset(ubh,begin,bit))
290 #define ubh_find_first_zero_bit(ubh,begin,size) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,0)
292 #define ubh_find_next_zero_bit(ubh,begin,size,offset) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,offset)
293 static inline unsigned _ubh_find_next_zero_bit_(
294 struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
295 unsigned begin
, unsigned size
, unsigned offset
)
297 unsigned base
, count
, pos
;
302 base
= offset
>> uspi
->s_bpfshift
;
303 offset
&= uspi
->s_bpfmask
;
305 count
= min (size
+ offset
, uspi
->s_bpf
);
306 size
-= count
- offset
;
307 pos
= ext2_find_next_zero_bit (ubh
->bh
[base
]->b_data
, count
, offset
);
308 if (pos
< count
|| !size
)
313 return (base
<< uspi
->s_bpfshift
) + pos
- begin
;
316 static inline unsigned find_last_zero_bit (unsigned char * bitmap
,
317 unsigned size
, unsigned offset
)
320 unsigned char * mapp
;
323 mapp
= bitmap
+ (size
>> 3);
325 bit
= 1 << (size
& 7);
326 for (i
= size
; i
> offset
; i
--) {
327 if ((map
& bit
) == 0)
339 #define ubh_find_last_zero_bit(ubh,begin,size,offset) _ubh_find_last_zero_bit_(uspi,ubh,begin,size,offset)
340 static inline unsigned _ubh_find_last_zero_bit_(
341 struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
342 unsigned begin
, unsigned start
, unsigned end
)
344 unsigned base
, count
, pos
, size
;
349 base
= start
>> uspi
->s_bpfshift
;
350 start
&= uspi
->s_bpfmask
;
352 count
= min (size
+ (uspi
->s_bpf
- start
), uspi
->s_bpf
)
353 - (uspi
->s_bpf
- start
);
355 pos
= find_last_zero_bit (ubh
->bh
[base
]->b_data
,
356 start
, start
- count
);
357 if (pos
> start
- count
|| !size
)
362 return (base
<< uspi
->s_bpfshift
) + pos
- begin
;
365 #define ubh_isblockclear(ubh,begin,block) (!_ubh_isblockset_(uspi,ubh,begin,block))
367 #define ubh_isblockset(ubh,begin,block) _ubh_isblockset_(uspi,ubh,begin,block)
368 static inline int _ubh_isblockset_(struct ufs_sb_private_info
* uspi
,
369 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
371 switch (uspi
->s_fpb
) {
373 return (*ubh_get_addr (ubh
, begin
+ block
) == 0xff);
375 return (*ubh_get_addr (ubh
, begin
+ (block
>> 1)) == (0x0f << ((block
& 0x01) << 2)));
377 return (*ubh_get_addr (ubh
, begin
+ (block
>> 2)) == (0x03 << ((block
& 0x03) << 1)));
379 return (*ubh_get_addr (ubh
, begin
+ (block
>> 3)) == (0x01 << (block
& 0x07)));
384 #define ubh_clrblock(ubh,begin,block) _ubh_clrblock_(uspi,ubh,begin,block)
385 static inline void _ubh_clrblock_(struct ufs_sb_private_info
* uspi
,
386 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
388 switch (uspi
->s_fpb
) {
390 *ubh_get_addr (ubh
, begin
+ block
) = 0x00;
393 *ubh_get_addr (ubh
, begin
+ (block
>> 1)) &= ~(0x0f << ((block
& 0x01) << 2));
396 *ubh_get_addr (ubh
, begin
+ (block
>> 2)) &= ~(0x03 << ((block
& 0x03) << 1));
399 *ubh_get_addr (ubh
, begin
+ (block
>> 3)) &= ~(0x01 << ((block
& 0x07)));
404 #define ubh_setblock(ubh,begin,block) _ubh_setblock_(uspi,ubh,begin,block)
405 static inline void _ubh_setblock_(struct ufs_sb_private_info
* uspi
,
406 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
408 switch (uspi
->s_fpb
) {
410 *ubh_get_addr(ubh
, begin
+ block
) = 0xff;
413 *ubh_get_addr(ubh
, begin
+ (block
>> 1)) |= (0x0f << ((block
& 0x01) << 2));
416 *ubh_get_addr(ubh
, begin
+ (block
>> 2)) |= (0x03 << ((block
& 0x03) << 1));
419 *ubh_get_addr(ubh
, begin
+ (block
>> 3)) |= (0x01 << ((block
& 0x07)));
424 static inline void ufs_fragacct (struct super_block
* sb
, unsigned blockmap
,
425 unsigned * fraglist
, int cnt
)
427 struct ufs_sb_private_info
* uspi
;
428 unsigned fragsize
, pos
;
431 swab
= sb
->u
.ufs_sb
.s_swab
;
432 uspi
= sb
->u
.ufs_sb
.s_uspi
;
435 for (pos
= 0; pos
< uspi
->s_fpb
; pos
++) {
436 if (blockmap
& (1 << pos
)) {
439 else if (fragsize
> 0) {
440 ADD_SWAB32(fraglist
[fragsize
], cnt
);
444 if (fragsize
> 0 && fragsize
< uspi
->s_fpb
)
445 ADD_SWAB32(fraglist
[fragsize
], cnt
);
448 #define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
449 static inline unsigned _ubh_scanc_(struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
450 unsigned begin
, unsigned size
, unsigned char * table
, unsigned char mask
)
452 unsigned rest
, offset
;
456 offset
= begin
& ~uspi
->s_fmask
;
457 begin
>>= uspi
->s_fshift
;
459 if ((offset
+ size
) < uspi
->s_fsize
)
462 rest
= uspi
->s_fsize
- offset
;
464 cp
= ubh
->bh
[begin
]->b_data
+ offset
;
465 while ((table
[*cp
++] & mask
) == 0 && --rest
);
471 return (size
+ rest
);