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