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 min(x,y) ((x)<(y)?(x):(y))
18 #define max(x,y) ((x)>(y)?(x):(y))
23 * macros used for retyping
25 #define UCPI_UBH ((struct ufs_buffer_head *)ucpi)
26 #define USPI_UBH ((struct ufs_buffer_head *)uspi)
31 * macros used for accesing structures
33 #define ufs_get_fs_state(usb1,usb3) _ufs_get_fs_state_(usb1,usb3,flags,swab)
34 static inline __s32
_ufs_get_fs_state_(struct ufs_super_block_first
* usb1
,
35 struct ufs_super_block_third
* usb3
, unsigned flags
, unsigned swab
)
37 switch (flags
& UFS_ST_MASK
) {
39 return SWAB32((usb3
)->fs_u2
.fs_sun
.fs_state
);
41 return SWAB32((usb1
)->fs_u1
.fs_sunx86
.fs_state
);
44 return SWAB32((usb3
)->fs_u2
.fs_44
.fs_state
);
48 #define ufs_set_fs_state(usb1,usb3,value) _ufs_set_fs_state_(usb1,usb3,value,flags,swab)
49 static inline void _ufs_set_fs_state_(struct ufs_super_block_first
* usb1
,
50 struct ufs_super_block_third
* usb3
, __s32 value
, unsigned flags
, unsigned swab
)
52 switch (flags
& UFS_ST_MASK
) {
54 (usb3
)->fs_u2
.fs_sun
.fs_state
= SWAB32(value
);
57 (usb1
)->fs_u1
.fs_sunx86
.fs_state
= SWAB32(value
);
60 (usb3
)->fs_u2
.fs_44
.fs_state
= SWAB32(value
);
65 #define ufs_get_fs_npsect(usb1,usb3) _ufs_get_fs_npsect_(usb1,usb3,flags,swab)
66 static inline __u32
_ufs_get_fs_npsect_(struct ufs_super_block_first
* usb1
,
67 struct ufs_super_block_third
* usb3
, unsigned flags
, unsigned swab
)
69 if ((flags
& UFS_ST_MASK
) == UFS_ST_SUNx86
)
70 return SWAB32((usb3
)->fs_u2
.fs_sunx86
.fs_npsect
);
72 return SWAB32((usb1
)->fs_u1
.fs_sun
.fs_npsect
);
75 #define ufs_get_fs_qbmask(usb3) _ufs_get_fs_qbmask_(usb3,flags,swab)
76 static inline __u64
_ufs_get_fs_qbmask_(struct ufs_super_block_third
* usb3
,
77 unsigned flags
, unsigned swab
)
80 switch (flags
& UFS_ST_MASK
) {
82 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_sun
.fs_qbmask
[0];
83 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_sun
.fs_qbmask
[1];
86 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_sunx86
.fs_qbmask
[0];
87 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_sunx86
.fs_qbmask
[1];
90 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_44
.fs_qbmask
[0];
91 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_44
.fs_qbmask
[1];
97 #define ufs_get_fs_qfmask(usb3) _ufs_get_fs_qfmask_(usb3,flags,swab)
98 static inline __u64
_ufs_get_fs_qfmask_(struct ufs_super_block_third
* usb3
,
99 unsigned flags
, unsigned swab
)
102 switch (flags
& UFS_ST_MASK
) {
104 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_sun
.fs_qfmask
[0];
105 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_sun
.fs_qfmask
[1];
108 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_sunx86
.fs_qfmask
[0];
109 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_sunx86
.fs_qfmask
[1];
112 ((u32
*)&tmp
)[0] = usb3
->fs_u2
.fs_44
.fs_qfmask
[0];
113 ((u32
*)&tmp
)[1] = usb3
->fs_u2
.fs_44
.fs_qfmask
[1];
119 #define ufs_get_de_namlen(de) \
120 (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
121 ? SWAB16(de->d_u.d_namlen) \
122 : de->d_u.d_44.d_namlen)
124 #define ufs_set_de_namlen(de,value) \
125 (((flags & UFS_DE_MASK) == UFS_DE_OLD) \
126 ? (de->d_u.d_namlen = SWAB16(value)) \
127 : (de->d_u.d_44.d_namlen = value))
129 #define ufs_set_de_type(de,mode) _ufs_set_de_type_(de,mode,flags,swab)
130 static inline void _ufs_set_de_type_(struct ufs_dir_entry
* de
, int mode
,
131 unsigned flags
, unsigned swab
)
133 if ((flags
& UFS_DE_MASK
) == UFS_DE_44BSD
) {
134 switch (mode
& S_IFMT
) {
135 case S_IFSOCK
: de
->d_u
.d_44
.d_type
= DT_SOCK
; break;
136 case S_IFLNK
: de
->d_u
.d_44
.d_type
= DT_LNK
; break;
137 case S_IFREG
: de
->d_u
.d_44
.d_type
= DT_REG
; break;
138 case S_IFBLK
: de
->d_u
.d_44
.d_type
= DT_BLK
; break;
139 case S_IFDIR
: de
->d_u
.d_44
.d_type
= DT_DIR
; break;
140 case S_IFCHR
: de
->d_u
.d_44
.d_type
= DT_CHR
; break;
141 case S_IFIFO
: de
->d_u
.d_44
.d_type
= DT_FIFO
; break;
142 default: de
->d_u
.d_44
.d_type
= DT_UNKNOWN
;
147 #define ufs_get_inode_uid(inode) _ufs_get_inode_uid_(inode,flags,swab)
148 static inline __u32
_ufs_get_inode_uid_(struct ufs_inode
* inode
,
149 unsigned flags
, unsigned swab
)
151 switch (flags
& UFS_UID_MASK
) {
153 return SWAB32(inode
->ui_u3
.ui_sun
.ui_uid
);
155 return SWAB32(inode
->ui_u3
.ui_44
.ui_uid
);
157 return SWAB16(inode
->ui_u1
.oldids
.ui_suid
);
161 #define ufs_set_inode_uid(inode,value) _ufs_set_inode_uid_(inode,value,flags,swab)
162 static inline void _ufs_set_inode_uid_(struct ufs_inode
* inode
, __u32 value
,
163 unsigned flags
, unsigned swab
)
165 inode
->ui_u1
.oldids
.ui_suid
= SWAB16(value
);
166 switch (flags
& UFS_UID_MASK
) {
168 inode
->ui_u3
.ui_sun
.ui_uid
= SWAB32(value
);
171 inode
->ui_u3
.ui_44
.ui_uid
= SWAB32(value
);
176 #define ufs_get_inode_gid(inode) _ufs_get_inode_gid_(inode,flags,swab)
177 static inline __u32
_ufs_get_inode_gid_(struct ufs_inode
* inode
,
178 unsigned flags
, unsigned swab
)
180 switch (flags
& UFS_UID_MASK
) {
182 return SWAB32(inode
->ui_u3
.ui_sun
.ui_gid
);
184 return SWAB32(inode
->ui_u3
.ui_44
.ui_gid
);
186 return SWAB16(inode
->ui_u1
.oldids
.ui_sgid
);
190 #define ufs_set_inode_gid(inode,value) _ufs_set_inode_gid_(inode,value,flags,swab)
191 static inline void _ufs_set_inode_gid_(struct ufs_inode
* inode
, __u32 value
,
192 unsigned flags
, unsigned swab
)
194 inode
->ui_u1
.oldids
.ui_sgid
= SWAB16(value
);
195 switch (flags
& UFS_UID_MASK
) {
197 inode
->ui_u3
.ui_sun
.ui_gid
= SWAB32(value
);
200 inode
->ui_u3
.ui_44
.ui_gid
= SWAB32(value
);
208 * These functions manipulate ufs buffers
210 #define ubh_bread(dev,fragment,size) _ubh_bread_(uspi,dev,fragment,size)
211 extern struct ufs_buffer_head
* _ubh_bread_(struct ufs_sb_private_info
*, kdev_t
, unsigned, unsigned);
212 extern struct ufs_buffer_head
* ubh_bread_uspi(struct ufs_sb_private_info
*, kdev_t
, unsigned, unsigned);
213 extern void ubh_brelse (struct ufs_buffer_head
*);
214 extern void ubh_brelse_uspi (struct ufs_sb_private_info
*);
215 extern void ubh_mark_buffer_dirty (struct ufs_buffer_head
*);
216 extern void ubh_mark_buffer_uptodate (struct ufs_buffer_head
*, int);
217 extern void ubh_ll_rw_block (int, unsigned, struct ufs_buffer_head
**);
218 extern void ubh_wait_on_buffer (struct ufs_buffer_head
*);
219 extern unsigned ubh_max_bcount (struct ufs_buffer_head
*);
220 extern void ubh_bforget (struct ufs_buffer_head
*);
221 extern int ubh_buffer_dirty (struct ufs_buffer_head
*);
222 #define ubh_ubhcpymem(mem,ubh,size) _ubh_ubhcpymem_(uspi,mem,ubh,size)
223 extern void _ubh_ubhcpymem_(struct ufs_sb_private_info
*, unsigned char *, struct ufs_buffer_head
*, unsigned);
224 #define ubh_memcpyubh(ubh,mem,size) _ubh_memcpyubh_(uspi,ubh,mem,size)
225 extern void _ubh_memcpyubh_(struct ufs_sb_private_info
*, struct ufs_buffer_head
*, unsigned char *, unsigned);
230 * macros to get important structures from ufs_buffer_head
232 #define ubh_get_usb_first(ubh) \
233 ((struct ufs_super_block_first *)((ubh)->bh[0]->b_data))
235 #define ubh_get_usb_second(ubh) \
236 ((struct ufs_super_block_second *)(ubh)-> \
237 bh[UFS_SECTOR_SIZE >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE & ~uspi->s_fmask))
239 #define ubh_get_usb_third(ubh) \
240 ((struct ufs_super_block_third *)((ubh)-> \
241 bh[UFS_SECTOR_SIZE*2 >> uspi->s_fshift]->b_data + (UFS_SECTOR_SIZE*2 & ~uspi->s_fmask)))
243 #define ubh_get_ucg(ubh) \
244 ((struct ufs_cylinder_group *)((ubh)->bh[0]->b_data))
248 * Extract byte from ufs_buffer_head
249 * Extract the bits for a block from a map inside ufs_buffer_head
251 #define ubh_get_addr8(ubh,begin) \
252 ((u8*)(ubh)->bh[(begin) >> uspi->s_fshift]->b_data + \
253 ((begin) & ~uspi->s_fmask))
255 #define ubh_get_addr16(ubh,begin) \
256 (((u16*)((ubh)->bh[(begin) >> (uspi->s_fshift-1)]->b_data)) + \
257 ((begin) & (uspi->fsize>>1) - 1)))
259 #define ubh_get_addr32(ubh,begin) \
260 (((u32*)((ubh)->bh[(begin) >> (uspi->s_fshift-2)]->b_data)) + \
261 ((begin) & ((uspi->s_fsize>>2) - 1)))
263 #define ubh_get_addr ubh_get_addr8
265 #define ubh_blkmap(ubh,begin,bit) \
266 ((*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) >> ((bit) & 7)) & (0xff >> (UFS_MAXFRAG - uspi->s_fpb)))
270 * Macros for access to superblock array structures
272 #define ubh_postbl(ubh,cylno,i) \
273 ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
274 ? (*(__s16*)(ubh_get_addr(ubh, \
275 (unsigned)(&((struct ufs_super_block *)0)->fs_opostbl) \
276 + (((cylno) * 16 + (i)) << 1) ) )) \
277 : (*(__s16*)(ubh_get_addr(ubh, \
278 uspi->s_postbloff + (((cylno) * uspi->s_nrpos + (i)) << 1) ))))
280 #define ubh_rotbl(ubh,i) \
281 ((uspi->s_postblformat != UFS_DYNAMICPOSTBLFMT) \
282 ? (*(__u8*)(ubh_get_addr(ubh, \
283 (unsigned)(&((struct ufs_super_block *)0)->fs_space) + (i)))) \
284 : (*(__u8*)(ubh_get_addr(ubh, uspi->s_rotbloff + (i)))))
287 * Determine the number of available frags given a
288 * percentage to hold in reserve.
290 #define ufs_freespace(usb, percentreserved) \
291 (ufs_blkstofrags(SWAB32((usb)->fs_cstotal.cs_nbfree)) + \
292 SWAB32((usb)->fs_cstotal.cs_nffree) - (uspi->s_dsize * (percentreserved) / 100))
295 * Macros to access cylinder group array structures
297 #define ubh_cg_blktot(ucpi,cylno) \
298 (*((__u32*)ubh_get_addr(UCPI_UBH, (ucpi)->c_btotoff + ((cylno) << 2))))
300 #define ubh_cg_blks(ucpi,cylno,rpos) \
301 (*((__u16*)ubh_get_addr(UCPI_UBH, \
302 (ucpi)->c_boff + (((cylno) * uspi->s_nrpos + (rpos)) << 1 ))))
306 * These functions work like classical bitmap operations.
307 * The difference is that we don't have the whole bitmap
308 * in one contiguous chunk of memory, but in several buffers.
309 * The parameters of each function are super_block, ufs_buffer_head and
310 * position of the beginning of the bitmap.
312 #define ubh_setbit(ubh,begin,bit) \
313 (*ubh_get_addr(ubh, (begin) + ((bit) >> 3)) |= (1 << ((bit) & 7)))
315 #define ubh_clrbit(ubh,begin,bit) \
316 (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) &= ~(1 << ((bit) & 7)))
318 #define ubh_isset(ubh,begin,bit) \
319 (*ubh_get_addr (ubh, (begin) + ((bit) >> 3)) & (1 << ((bit) & 7)))
321 #define ubh_isclr(ubh,begin,bit) (!ubh_isset(ubh,begin,bit))
323 #define ubh_find_first_zero_bit(ubh,begin,size) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,0)
325 #define ubh_find_next_zero_bit(ubh,begin,size,offset) _ubh_find_next_zero_bit_(uspi,ubh,begin,size,offset)
326 static inline unsigned _ubh_find_next_zero_bit_(
327 struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
328 unsigned begin
, unsigned size
, unsigned offset
)
330 unsigned base
, count
, pos
;
335 base
= offset
>> uspi
->s_bpfshift
;
336 offset
&= uspi
->s_bpfmask
;
338 count
= min (size
+ offset
, uspi
->s_bpf
);
339 size
-= count
- offset
;
340 pos
= ext2_find_next_zero_bit (ubh
->bh
[base
]->b_data
, count
, offset
);
341 if (pos
< count
|| !size
)
346 return (base
<< uspi
->s_bpfshift
) + pos
- begin
;
349 static inline unsigned find_last_zero_bit (unsigned char * bitmap
,
350 unsigned size
, unsigned offset
)
353 unsigned char * mapp
;
356 mapp
= bitmap
+ (size
>> 3);
358 bit
= 1 << (size
& 7);
359 for (i
= size
; i
> offset
; i
--) {
360 if ((map
& bit
) == 0)
372 #define ubh_find_last_zero_bit(ubh,begin,size,offset) _ubh_find_last_zero_bit_(uspi,ubh,begin,size,offset)
373 static inline unsigned _ubh_find_last_zero_bit_(
374 struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
375 unsigned begin
, unsigned start
, unsigned end
)
377 unsigned base
, count
, pos
, size
;
382 base
= start
>> uspi
->s_bpfshift
;
383 start
&= uspi
->s_bpfmask
;
385 count
= min (size
+ (uspi
->s_bpf
- start
), uspi
->s_bpf
)
386 - (uspi
->s_bpf
- start
);
388 pos
= find_last_zero_bit (ubh
->bh
[base
]->b_data
,
389 start
, start
- count
);
390 if (pos
> start
- count
|| !size
)
395 return (base
<< uspi
->s_bpfshift
) + pos
- begin
;
398 #define ubh_isblockclear(ubh,begin,block) (!_ubh_isblockset_(uspi,ubh,begin,block))
400 #define ubh_isblockset(ubh,begin,block) _ubh_isblockset_(uspi,ubh,begin,block)
401 static inline int _ubh_isblockset_(struct ufs_sb_private_info
* uspi
,
402 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
404 switch (uspi
->s_fpb
) {
406 return (*ubh_get_addr (ubh
, begin
+ block
) == 0xff);
408 return (*ubh_get_addr (ubh
, begin
+ (block
>> 1)) == (0x0f << ((block
& 0x01) << 2)));
410 return (*ubh_get_addr (ubh
, begin
+ (block
>> 2)) == (0x03 << ((block
& 0x03) << 1)));
412 return (*ubh_get_addr (ubh
, begin
+ (block
>> 3)) == (0x01 << (block
& 0x07)));
417 #define ubh_clrblock(ubh,begin,block) _ubh_clrblock_(uspi,ubh,begin,block)
418 static inline void _ubh_clrblock_(struct ufs_sb_private_info
* uspi
,
419 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
421 switch (uspi
->s_fpb
) {
423 *ubh_get_addr (ubh
, begin
+ block
) = 0x00;
426 *ubh_get_addr (ubh
, begin
+ (block
>> 1)) &= ~(0x0f << ((block
& 0x01) << 2));
429 *ubh_get_addr (ubh
, begin
+ (block
>> 2)) &= ~(0x03 << ((block
& 0x03) << 1));
432 *ubh_get_addr (ubh
, begin
+ (block
>> 3)) &= ~(0x01 << ((block
& 0x07)));
437 #define ubh_setblock(ubh,begin,block) _ubh_setblock_(uspi,ubh,begin,block)
438 static inline void _ubh_setblock_(struct ufs_sb_private_info
* uspi
,
439 struct ufs_buffer_head
* ubh
, unsigned begin
, unsigned block
)
441 switch (uspi
->s_fpb
) {
443 *ubh_get_addr(ubh
, begin
+ block
) = 0xff;
446 *ubh_get_addr(ubh
, begin
+ (block
>> 1)) |= (0x0f << ((block
& 0x01) << 2));
449 *ubh_get_addr(ubh
, begin
+ (block
>> 2)) |= (0x03 << ((block
& 0x03) << 1));
452 *ubh_get_addr(ubh
, begin
+ (block
>> 3)) |= (0x01 << ((block
& 0x07)));
457 static inline void ufs_fragacct (struct super_block
* sb
, unsigned blockmap
,
458 unsigned * fraglist
, int cnt
)
460 struct ufs_sb_private_info
* uspi
;
461 unsigned fragsize
, pos
;
464 swab
= sb
->u
.ufs_sb
.s_swab
;
465 uspi
= sb
->u
.ufs_sb
.s_uspi
;
468 for (pos
= 0; pos
< uspi
->s_fpb
; pos
++) {
469 if (blockmap
& (1 << pos
)) {
472 else if (fragsize
> 0) {
473 ADD_SWAB32(fraglist
[fragsize
], cnt
);
477 if (fragsize
> 0 && fragsize
< uspi
->s_fpb
)
478 ADD_SWAB32(fraglist
[fragsize
], cnt
);
481 #define ubh_scanc(ubh,begin,size,table,mask) _ubh_scanc_(uspi,ubh,begin,size,table,mask)
482 static inline unsigned _ubh_scanc_(struct ufs_sb_private_info
* uspi
, struct ufs_buffer_head
* ubh
,
483 unsigned begin
, unsigned size
, unsigned char * table
, unsigned char mask
)
485 unsigned rest
, offset
;
489 offset
= begin
& ~uspi
->s_fmask
;
490 begin
>>= uspi
->s_fshift
;
492 if ((offset
+ size
) < uspi
->s_fsize
)
495 rest
= uspi
->s_fsize
- offset
;
497 cp
= ubh
->bh
[begin
]->b_data
+ offset
;
498 while ((table
[*cp
++] & mask
) == 0 && --rest
);
504 return (size
+ rest
);