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