1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2018-2019 HUAWEI, Inc.
4 * https://www.huawei.com/
5 */
6 #include "internal.h"
7 #include <asm/unaligned.h>
8 #include <trace/events/erofs.h>
9
10 struct z_erofs_maprecorder {
11 struct inode *inode;
12 struct erofs_map_blocks *map;
13 void *kaddr;
14
15 unsigned long lcn;
16 /* compression extent information gathered */
17 u8 type, headtype;
18 u16 clusterofs;
19 u16 delta[2];
20 erofs_blk_t pblk, compressedblks;
21 erofs_off_t nextpackoff;
22 bool partialref;
23 };
24
25 static int z_erofs_load_full_lcluster(struct z_erofs_maprecorder *m,
26 unsigned long lcn)
27 {
28 struct inode *const inode = m->inode;
29 struct erofs_inode *const vi = EROFS_I(inode);
30 const erofs_off_t pos = Z_EROFS_FULL_INDEX_ALIGN(erofs_iloc(inode) +
31 vi->inode_isize + vi->xattr_isize) +
32 lcn * sizeof(struct z_erofs_lcluster_index);
33 struct z_erofs_lcluster_index *di;
34 unsigned int advise;
35
36 m->kaddr = erofs_read_metabuf(&m->map->buf, inode->i_sb,
37 pos, EROFS_KMAP);
38 if (IS_ERR(m->kaddr))
39 return PTR_ERR(m->kaddr);
40
41 m->nextpackoff = pos + sizeof(struct z_erofs_lcluster_index);
42 m->lcn = lcn;
43 di = m->kaddr;
44
45 advise = le16_to_cpu(di->di_advise);
46 m->type = advise & Z_EROFS_LI_LCLUSTER_TYPE_MASK;
47 if (m->type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
48 m->clusterofs = 1 << vi->z_logical_clusterbits;
49 m->delta[0] = le16_to_cpu(di->di_u.delta[0]);
50 if (m->delta[0] & Z_EROFS_LI_D0_CBLKCNT) {
51 if (!(vi->z_advise & (Z_EROFS_ADVISE_BIG_PCLUSTER_1 |
52 Z_EROFS_ADVISE_BIG_PCLUSTER_2))) {
53 DBG_BUGON(1);
54 return -EFSCORRUPTED;
55 }
56 m->compressedblks = m->delta[0] &
57 ~Z_EROFS_LI_D0_CBLKCNT;
58 m->delta[0] = 1;
59 }
60 m->delta[1] = le16_to_cpu(di->di_u.delta[1]);
61 } else {
62 m->partialref = !!(advise & Z_EROFS_LI_PARTIAL_REF);
63 m->clusterofs = le16_to_cpu(di->di_clusterofs);
64 if (m->clusterofs >= 1 << vi->z_logical_clusterbits) {
65 DBG_BUGON(1);
66 return -EFSCORRUPTED;
67 }
68 m->pblk = le32_to_cpu(di->di_u.blkaddr);
69 }
70 return 0;
71 }
72
73 static unsigned int decode_compactedbits(unsigned int lobits,
74 u8 *in, unsigned int pos, u8 *type)
75 {
76 const unsigned int v = get_unaligned_le32(in + pos / 8) >> (pos & 7);
77 const unsigned int lo = v & ((1 << lobits) - 1);
78
79 *type = (v >> lobits) & 3;
80 return lo;
81 }
82
83 static int get_compacted_la_distance(unsigned int lobits,
84 unsigned int encodebits,
85 unsigned int vcnt, u8 *in, int i)
86 {
87 unsigned int lo, d1 = 0;
88 u8 type;
89
90 DBG_BUGON(i >= vcnt);
91
92 do {
93 lo = decode_compactedbits(lobits, in, encodebits * i, &type);
94
95 if (type != Z_EROFS_LCLUSTER_TYPE_NONHEAD)
96 return d1;
97 ++d1;
98 } while (++i < vcnt);
99
100 /* vcnt - 1 (Z_EROFS_LCLUSTER_TYPE_NONHEAD) item */
101 if (!(lo & Z_EROFS_LI_D0_CBLKCNT))
102 d1 += lo - 1;
103 return d1;
104 }
105
106 static int unpack_compacted_index(struct z_erofs_maprecorder *m,
107 unsigned int amortizedshift,
108 erofs_off_t pos, bool lookahead)
109 {
110 struct erofs_inode *const vi = EROFS_I(m->inode);
111 const unsigned int lclusterbits = vi->z_logical_clusterbits;
112 unsigned int vcnt, lo, lobits, encodebits, nblk, bytes;
113 int i;
114 u8 *in, type;
115 bool big_pcluster;
116
117 if (1 << amortizedshift == 4 && lclusterbits <= 14)
118 vcnt = 2;
119 else if (1 << amortizedshift == 2 && lclusterbits <= 12)
120 vcnt = 16;
121 else
122 return -EOPNOTSUPP;
123
124 /* it doesn't equal to round_up(..) */
125 m->nextpackoff = round_down(pos, vcnt << amortizedshift) +
126 (vcnt << amortizedshift);
127 big_pcluster = vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_1;
128 lobits = max(lclusterbits, ilog2(Z_EROFS_LI_D0_CBLKCNT) + 1U);
129 encodebits = ((vcnt << amortizedshift) - sizeof(__le32)) * 8 / vcnt;
130 bytes = pos & ((vcnt << amortizedshift) - 1);
131
132 in = m->kaddr - bytes;
133
134 i = bytes >> amortizedshift;
135
136 lo = decode_compactedbits(lobits, in, encodebits * i, &type);
137 m->type = type;
138 if (type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
139 m->clusterofs = 1 << lclusterbits;
140
141 /* figure out lookahead_distance: delta[1] if needed */
142 if (lookahead)
143 m->delta[1] = get_compacted_la_distance(lobits,
144 encodebits, vcnt, in, i);
145 if (lo & Z_EROFS_LI_D0_CBLKCNT) {
146 if (!big_pcluster) {
147 DBG_BUGON(1);
148 return -EFSCORRUPTED;
149 }
150 m->compressedblks = lo & ~Z_EROFS_LI_D0_CBLKCNT;
151 m->delta[0] = 1;
152 return 0;
153 } else if (i + 1 != (int)vcnt) {
154 m->delta[0] = lo;
155 return 0;
156 }
157 /*
158 * since the last lcluster in the pack is special,
159 * of which lo saves delta[1] rather than delta[0].
160 * Hence, get delta[0] by the previous lcluster indirectly.
161 */
162 lo = decode_compactedbits(lobits, in,
163 encodebits * (i - 1), &type);
164 if (type != Z_EROFS_LCLUSTER_TYPE_NONHEAD)
165 lo = 0;
166 else if (lo & Z_EROFS_LI_D0_CBLKCNT)
167 lo = 1;
168 m->delta[0] = lo + 1;
169 return 0;
170 }
171 m->clusterofs = lo;
172 m->delta[0] = 0;
173 /* figout out blkaddr (pblk) for HEAD lclusters */
174 if (!big_pcluster) {
175 nblk = 1;
176 while (i > 0) {
177 --i;
178 lo = decode_compactedbits(lobits, in,
179 encodebits * i, &type);
180 if (type == Z_EROFS_LCLUSTER_TYPE_NONHEAD)
181 i -= lo;
182
183 if (i >= 0)
184 ++nblk;
185 }
186 } else {
187 nblk = 0;
188 while (i > 0) {
189 --i;
190 lo = decode_compactedbits(lobits, in,
191 encodebits * i, &type);
192 if (type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
193 if (lo & Z_EROFS_LI_D0_CBLKCNT) {
194 --i;
195 nblk += lo & ~Z_EROFS_LI_D0_CBLKCNT;
196 continue;
197 }
198 /* bigpcluster shouldn't have plain d0 == 1 */
199 if (lo <= 1) {
200 DBG_BUGON(1);
201 return -EFSCORRUPTED;
202 }
203 i -= lo - 2;
204 continue;
205 }
206 ++nblk;
207 }
208 }
209 in += (vcnt << amortizedshift) - sizeof(__le32);
210 m->pblk = le32_to_cpu(*(__le32 *)in) + nblk;
211 return 0;
212 }
213
214 static int z_erofs_load_compact_lcluster(struct z_erofs_maprecorder *m,
215 unsigned long lcn, bool lookahead)
216 {
217 struct inode *const inode = m->inode;
218 struct erofs_inode *const vi = EROFS_I(inode);
219 const erofs_off_t ebase = sizeof(struct z_erofs_map_header) +
220 ALIGN(erofs_iloc(inode) + vi->inode_isize + vi->xattr_isize, 8);
221 unsigned int totalidx = erofs_iblks(inode);
222 unsigned int compacted_4b_initial, compacted_2b;
223 unsigned int amortizedshift;
224 erofs_off_t pos;
225
226 if (lcn >= totalidx)
227 return -EINVAL;
228
229 m->lcn = lcn;
230 /* used to align to 32-byte (compacted_2b) alignment */
231 compacted_4b_initial = (32 - ebase % 32) / 4;
232 if (compacted_4b_initial == 32 / 4)
233 compacted_4b_initial = 0;
234
235 if ((vi->z_advise & Z_EROFS_ADVISE_COMPACTED_2B) &&
236 compacted_4b_initial < totalidx)
237 compacted_2b = rounddown(totalidx - compacted_4b_initial, 16);
238 else
239 compacted_2b = 0;
240
241 pos = ebase;
242 if (lcn < compacted_4b_initial) {
243 amortizedshift = 2;
244 goto out;
245 }
246 pos += compacted_4b_initial * 4;
247 lcn -= compacted_4b_initial;
248
249 if (lcn < compacted_2b) {
250 amortizedshift = 1;
251 goto out;
252 }
253 pos += compacted_2b * 2;
254 lcn -= compacted_2b;
255 amortizedshift = 2;
256 out:
257 pos += lcn * (1 << amortizedshift);
258 m->kaddr = erofs_read_metabuf(&m->map->buf, inode->i_sb,
259 pos, EROFS_KMAP);
260 if (IS_ERR(m->kaddr))
261 return PTR_ERR(m->kaddr);
262 return unpack_compacted_index(m, amortizedshift, pos, lookahead);
263 }
264
265 static int z_erofs_load_lcluster_from_disk(struct z_erofs_maprecorder *m,
266 unsigned int lcn, bool lookahead)
267 {
268 switch (EROFS_I(m->inode)->datalayout) {
269 case EROFS_INODE_COMPRESSED_FULL:
270 return z_erofs_load_full_lcluster(m, lcn);
271 case EROFS_INODE_COMPRESSED_COMPACT:
272 return z_erofs_load_compact_lcluster(m, lcn, lookahead);
273 default:
274 return -EINVAL;
275 }
276 }
277
278 static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m,
279 unsigned int lookback_distance)
280 {
281 struct super_block *sb = m->inode->i_sb;
282 struct erofs_inode *const vi = EROFS_I(m->inode);
283 const unsigned int lclusterbits = vi->z_logical_clusterbits;
284
285 while (m->lcn >= lookback_distance) {
286 unsigned long lcn = m->lcn - lookback_distance;
287 int err;
288
289 err = z_erofs_load_lcluster_from_disk(m, lcn, false);
290 if (err)
291 return err;
292
293 switch (m->type) {
294 case Z_EROFS_LCLUSTER_TYPE_NONHEAD:
295 lookback_distance = m->delta[0];
296 if (!lookback_distance)
297 goto err_bogus;
298 continue;
299 case Z_EROFS_LCLUSTER_TYPE_PLAIN:
300 case Z_EROFS_LCLUSTER_TYPE_HEAD1:
301 case Z_EROFS_LCLUSTER_TYPE_HEAD2:
302 m->headtype = m->type;
303 m->map->m_la = (lcn << lclusterbits) | m->clusterofs;
304 return 0;
305 default:
306 erofs_err(sb, "unknown type %u @ lcn %lu of nid %llu",
307 m->type, lcn, vi->nid);
308 DBG_BUGON(1);
309 return -EOPNOTSUPP;
310 }
311 }
312 err_bogus:
313 erofs_err(sb, "bogus lookback distance %u @ lcn %lu of nid %llu",
314 lookback_distance, m->lcn, vi->nid);
315 DBG_BUGON(1);
316 return -EFSCORRUPTED;
317 }
318
319 static int z_erofs_get_extent_compressedlen(struct z_erofs_maprecorder *m,
320 unsigned int initial_lcn)
321 {
322 struct super_block *sb = m->inode->i_sb;
323 struct erofs_inode *const vi = EROFS_I(m->inode);
324 struct erofs_map_blocks *const map = m->map;
325 const unsigned int lclusterbits = vi->z_logical_clusterbits;
326 unsigned long lcn;
327 int err;
328
329 DBG_BUGON(m->type != Z_EROFS_LCLUSTER_TYPE_PLAIN &&
330 m->type != Z_EROFS_LCLUSTER_TYPE_HEAD1 &&
331 m->type != Z_EROFS_LCLUSTER_TYPE_HEAD2);
332 DBG_BUGON(m->type != m->headtype);
333
334 if (m->headtype == Z_EROFS_LCLUSTER_TYPE_PLAIN ||
335 ((m->headtype == Z_EROFS_LCLUSTER_TYPE_HEAD1) &&
336 !(vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_1)) ||
337 ((m->headtype == Z_EROFS_LCLUSTER_TYPE_HEAD2) &&
338 !(vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_2))) {
339 map->m_plen = 1ULL << lclusterbits;
340 return 0;
341 }
342 lcn = m->lcn + 1;
343 if (m->compressedblks)
344 goto out;
345
346 err = z_erofs_load_lcluster_from_disk(m, lcn, false);
347 if (err)
348 return err;
349
350 /*
351 * If the 1st NONHEAD lcluster has already been handled initially w/o
352 * valid compressedblks, which means at least it mustn't be CBLKCNT, or
353 * an internal implemenatation error is detected.
354 *
355 * The following code can also handle it properly anyway, but let's
356 * BUG_ON in the debugging mode only for developers to notice that.
357 */
358 DBG_BUGON(lcn == initial_lcn &&
359 m->type == Z_EROFS_LCLUSTER_TYPE_NONHEAD);
360
361 switch (m->type) {
362 case Z_EROFS_LCLUSTER_TYPE_PLAIN:
363 case Z_EROFS_LCLUSTER_TYPE_HEAD1:
364 case Z_EROFS_LCLUSTER_TYPE_HEAD2:
365 /*
366 * if the 1st NONHEAD lcluster is actually PLAIN or HEAD type
367 * rather than CBLKCNT, it's a 1 lcluster-sized pcluster.
368 */
369 m->compressedblks = 1 << (lclusterbits - sb->s_blocksize_bits);
370 break;
371 case Z_EROFS_LCLUSTER_TYPE_NONHEAD:
372 if (m->delta[0] != 1)
373 goto err_bonus_cblkcnt;
374 if (m->compressedblks)
375 break;
376 fallthrough;
377 default:
378 erofs_err(sb, "cannot found CBLKCNT @ lcn %lu of nid %llu", lcn,
379 vi->nid);
380 DBG_BUGON(1);
381 return -EFSCORRUPTED;
382 }
383 out:
384 map->m_plen = erofs_pos(sb, m->compressedblks);
385 return 0;
386 err_bonus_cblkcnt:
387 erofs_err(sb, "bogus CBLKCNT @ lcn %lu of nid %llu", lcn, vi->nid);
388 DBG_BUGON(1);
389 return -EFSCORRUPTED;
390 }
391
392 static int z_erofs_get_extent_decompressedlen(struct z_erofs_maprecorder *m)
393 {
394 struct inode *inode = m->inode;
395 struct erofs_inode *vi = EROFS_I(inode);
396 struct erofs_map_blocks *map = m->map;
397 unsigned int lclusterbits = vi->z_logical_clusterbits;
398 u64 lcn = m->lcn, headlcn = map->m_la >> lclusterbits;
399 int err;
400
401 do {
402 /* handle the last EOF pcluster (no next HEAD lcluster) */
403 if ((lcn << lclusterbits) >= inode->i_size) {
404 map->m_llen = inode->i_size - map->m_la;
405 return 0;
406 }
407
408 err = z_erofs_load_lcluster_from_disk(m, lcn, true);
409 if (err)
410 return err;
411
412 if (m->type == Z_EROFS_LCLUSTER_TYPE_NONHEAD) {
413 DBG_BUGON(!m->delta[1] &&
414 m->clusterofs != 1 << lclusterbits);
415 } else if (m->type == Z_EROFS_LCLUSTER_TYPE_PLAIN ||
416 m->type == Z_EROFS_LCLUSTER_TYPE_HEAD1 ||
417 m->type == Z_EROFS_LCLUSTER_TYPE_HEAD2) {
418 /* go on until the next HEAD lcluster */
419 if (lcn != headlcn)
420 break;
421 m->delta[1] = 1;
422 } else {
423 erofs_err(inode->i_sb, "unknown type %u @ lcn %llu of nid %llu",
424 m->type, lcn, vi->nid);
425 DBG_BUGON(1);
426 return -EOPNOTSUPP;
427 }
428 lcn += m->delta[1];
429 } while (m->delta[1]);
430
431 map->m_llen = (lcn << lclusterbits) + m->clusterofs - map->m_la;
432 return 0;
433 }
434
435 static int z_erofs_do_map_blocks(struct inode *inode,
436 struct erofs_map_blocks *map, int flags)
437 {
438 struct erofs_inode *const vi = EROFS_I(inode);
439 bool ztailpacking = vi->z_advise & Z_EROFS_ADVISE_INLINE_PCLUSTER;
440 bool fragment = vi->z_advise & Z_EROFS_ADVISE_FRAGMENT_PCLUSTER;
441 struct z_erofs_maprecorder m = {
442 .inode = inode,
443 .map = map,
444 };
445 int err = 0;
446 unsigned int lclusterbits, endoff, afmt;
447 unsigned long initial_lcn;
448 unsigned long long ofs, end;
449
450 lclusterbits = vi->z_logical_clusterbits;
451 ofs = flags & EROFS_GET_BLOCKS_FINDTAIL ? inode->i_size - 1 : map->m_la;
452 initial_lcn = ofs >> lclusterbits;
453 endoff = ofs & ((1 << lclusterbits) - 1);
454
455 err = z_erofs_load_lcluster_from_disk(&m, initial_lcn, false);
456 if (err)
457 goto unmap_out;
458
459 if (ztailpacking && (flags & EROFS_GET_BLOCKS_FINDTAIL))
460 vi->z_idataoff = m.nextpackoff;
461
462 map->m_flags = EROFS_MAP_MAPPED | EROFS_MAP_ENCODED;
463 end = (m.lcn + 1ULL) << lclusterbits;
464
465 switch (m.type) {
466 case Z_EROFS_LCLUSTER_TYPE_PLAIN:
467 case Z_EROFS_LCLUSTER_TYPE_HEAD1:
468 case Z_EROFS_LCLUSTER_TYPE_HEAD2:
469 if (endoff >= m.clusterofs) {
470 m.headtype = m.type;
471 map->m_la = (m.lcn << lclusterbits) | m.clusterofs;
472 /*
473 * For ztailpacking files, in order to inline data more
474 * effectively, special EOF lclusters are now supported
475 * which can have three parts at most.
476 */
477 if (ztailpacking && end > inode->i_size)
478 end = inode->i_size;
479 break;
480 }
481 /* m.lcn should be >= 1 if endoff < m.clusterofs */
482 if (!m.lcn) {
483 erofs_err(inode->i_sb,
484 "invalid logical cluster 0 at nid %llu",
485 vi->nid);
486 err = -EFSCORRUPTED;
487 goto unmap_out;
488 }
489 end = (m.lcn << lclusterbits) | m.clusterofs;
490 map->m_flags |= EROFS_MAP_FULL_MAPPED;
491 m.delta[0] = 1;
492 fallthrough;
493 case Z_EROFS_LCLUSTER_TYPE_NONHEAD:
494 /* get the corresponding first chunk */
495 err = z_erofs_extent_lookback(&m, m.delta[0]);
496 if (err)
497 goto unmap_out;
498 break;
499 default:
500 erofs_err(inode->i_sb,
501 "unknown type %u @ offset %llu of nid %llu",
502 m.type, ofs, vi->nid);
503 err = -EOPNOTSUPP;
504 goto unmap_out;
505 }
506 if (m.partialref)
507 map->m_flags |= EROFS_MAP_PARTIAL_REF;
508 map->m_llen = end - map->m_la;
509
510 if (flags & EROFS_GET_BLOCKS_FINDTAIL) {
511 vi->z_tailextent_headlcn = m.lcn;
512 /* for non-compact indexes, fragmentoff is 64 bits */
513 if (fragment && vi->datalayout == EROFS_INODE_COMPRESSED_FULL)
514 vi->z_fragmentoff |= (u64)m.pblk << 32;
515 }
516 if (ztailpacking && m.lcn == vi->z_tailextent_headlcn) {
517 map->m_flags |= EROFS_MAP_META;
518 map->m_pa = vi->z_idataoff;
519 map->m_plen = vi->z_idata_size;
520 } else if (fragment && m.lcn == vi->z_tailextent_headlcn) {
521 map->m_flags |= EROFS_MAP_FRAGMENT;
522 } else {
523 map->m_pa = erofs_pos(inode->i_sb, m.pblk);
524 err = z_erofs_get_extent_compressedlen(&m, initial_lcn);
525 if (err)
526 goto unmap_out;
527 }
528
529 if (m.headtype == Z_EROFS_LCLUSTER_TYPE_PLAIN) {
530 if (map->m_llen > map->m_plen) {
531 DBG_BUGON(1);
532 err = -EFSCORRUPTED;
533 goto unmap_out;
534 }
535 afmt = vi->z_advise & Z_EROFS_ADVISE_INTERLACED_PCLUSTER ?
536 Z_EROFS_COMPRESSION_INTERLACED :
537 Z_EROFS_COMPRESSION_SHIFTED;
538 } else {
539 afmt = m.headtype == Z_EROFS_LCLUSTER_TYPE_HEAD2 ?
540 vi->z_algorithmtype[1] : vi->z_algorithmtype[0];
541 if (!(EROFS_I_SB(inode)->available_compr_algs & (1 << afmt))) {
542 erofs_err(inode->i_sb, "inconsistent algorithmtype %u for nid %llu",
543 afmt, vi->nid);
544 err = -EFSCORRUPTED;
545 goto unmap_out;
546 }
547 }
548 map->m_algorithmformat = afmt;
549
550 if ((flags & EROFS_GET_BLOCKS_FIEMAP) ||
551 ((flags & EROFS_GET_BLOCKS_READMORE) &&
552 (map->m_algorithmformat == Z_EROFS_COMPRESSION_LZMA ||
553 map->m_algorithmformat == Z_EROFS_COMPRESSION_DEFLATE ||
554 map->m_algorithmformat == Z_EROFS_COMPRESSION_ZSTD) &&
555 map->m_llen >= i_blocksize(inode))) {
556 err = z_erofs_get_extent_decompressedlen(&m);
557 if (!err)
558 map->m_flags |= EROFS_MAP_FULL_MAPPED;
559 }
560
561 unmap_out:
562 erofs_unmap_metabuf(&m.map->buf);
563 return err;
564 }
565
566 static int z_erofs_fill_inode_lazy(struct inode *inode)
567 {
568 struct erofs_inode *const vi = EROFS_I(inode);
569 struct super_block *const sb = inode->i_sb;
570 int err, headnr;
571 erofs_off_t pos;
572 struct erofs_buf buf = __EROFS_BUF_INITIALIZER;
573 struct z_erofs_map_header *h;
574
575 if (test_bit(EROFS_I_Z_INITED_BIT, &vi->flags)) {
576 /*
577 * paired with smp_mb() at the end of the function to ensure
578 * fields will only be observed after the bit is set.
579 */
580 smp_mb();
581 return 0;
582 }
583
584 if (wait_on_bit_lock(&vi->flags, EROFS_I_BL_Z_BIT, TASK_KILLABLE))
585 return -ERESTARTSYS;
586
587 err = 0;
588 if (test_bit(EROFS_I_Z_INITED_BIT, &vi->flags))
589 goto out_unlock;
590
591 pos = ALIGN(erofs_iloc(inode) + vi->inode_isize + vi->xattr_isize, 8);
592 h = erofs_read_metabuf(&buf, sb, pos, EROFS_KMAP);
593 if (IS_ERR(h)) {
594 err = PTR_ERR(h);
595 goto out_unlock;
596 }
597
598 /*
599 * if the highest bit of the 8-byte map header is set, the whole file
600 * is stored in the packed inode. The rest bits keeps z_fragmentoff.
601 */
602 if (h->h_clusterbits >> Z_EROFS_FRAGMENT_INODE_BIT) {
603 vi->z_advise = Z_EROFS_ADVISE_FRAGMENT_PCLUSTER;
604 vi->z_fragmentoff = le64_to_cpu(*(__le64 *)h) ^ (1ULL << 63);
605 vi->z_tailextent_headlcn = 0;
606 goto done;
607 }
608 vi->z_advise = le16_to_cpu(h->h_advise);
609 vi->z_algorithmtype[0] = h->h_algorithmtype & 15;
610 vi->z_algorithmtype[1] = h->h_algorithmtype >> 4;
611
612 headnr = 0;
613 if (vi->z_algorithmtype[0] >= Z_EROFS_COMPRESSION_MAX ||
614 vi->z_algorithmtype[++headnr] >= Z_EROFS_COMPRESSION_MAX) {
615 erofs_err(sb, "unknown HEAD%u format %u for nid %llu, please upgrade kernel",
616 headnr + 1, vi->z_algorithmtype[headnr], vi->nid);
617 err = -EOPNOTSUPP;
618 goto out_put_metabuf;
619 }
620
621 vi->z_logical_clusterbits = sb->s_blocksize_bits + (h->h_clusterbits & 7);
622 if (!erofs_sb_has_big_pcluster(EROFS_SB(sb)) &&
623 vi->z_advise & (Z_EROFS_ADVISE_BIG_PCLUSTER_1 |
624 Z_EROFS_ADVISE_BIG_PCLUSTER_2)) {
625 erofs_err(sb, "per-inode big pcluster without sb feature for nid %llu",
626 vi->nid);
627 err = -EFSCORRUPTED;
628 goto out_put_metabuf;
629 }
630 if (vi->datalayout == EROFS_INODE_COMPRESSED_COMPACT &&
631 !(vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_1) ^
632 !(vi->z_advise & Z_EROFS_ADVISE_BIG_PCLUSTER_2)) {
633 erofs_err(sb, "big pcluster head1/2 of compact indexes should be consistent for nid %llu",
634 vi->nid);
635 err = -EFSCORRUPTED;
636 goto out_put_metabuf;
637 }
638
639 if (vi->z_advise & Z_EROFS_ADVISE_INLINE_PCLUSTER) {
640 struct erofs_map_blocks map = {
641 .buf = __EROFS_BUF_INITIALIZER
642 };
643
644 vi->z_idata_size = le16_to_cpu(h->h_idata_size);
645 err = z_erofs_do_map_blocks(inode, &map,
646 EROFS_GET_BLOCKS_FINDTAIL);
647 erofs_put_metabuf(&map.buf);
648
649 if (!map.m_plen ||
650 erofs_blkoff(sb, map.m_pa) + map.m_plen > sb->s_blocksize) {
651 erofs_err(sb, "invalid tail-packing pclustersize %llu",
652 map.m_plen);
653 err = -EFSCORRUPTED;
654 }
655 if (err < 0)
656 goto out_put_metabuf;
657 }
658
659 if (vi->z_advise & Z_EROFS_ADVISE_FRAGMENT_PCLUSTER &&
660 !(h->h_clusterbits >> Z_EROFS_FRAGMENT_INODE_BIT)) {
661 struct erofs_map_blocks map = {
662 .buf = __EROFS_BUF_INITIALIZER
663 };
664
665 vi->z_fragmentoff = le32_to_cpu(h->h_fragmentoff);
666 err = z_erofs_do_map_blocks(inode, &map,
667 EROFS_GET_BLOCKS_FINDTAIL);
668 erofs_put_metabuf(&map.buf);
669 if (err < 0)
670 goto out_put_metabuf;
671 }
672 done:
673 /* paired with smp_mb() at the beginning of the function */
674 smp_mb();
675 set_bit(EROFS_I_Z_INITED_BIT, &vi->flags);
676 out_put_metabuf:
677 erofs_put_metabuf(&buf);
678 out_unlock:
679 clear_and_wake_up_bit(EROFS_I_BL_Z_BIT, &vi->flags);
680 return err;
681 }
682
683 int z_erofs_map_blocks_iter(struct inode *inode, struct erofs_map_blocks *map,
684 int flags)
685 {
686 struct erofs_inode *const vi = EROFS_I(inode);
687 int err = 0;
688
689 trace_erofs_map_blocks_enter(inode, map, flags);
690
691 /* when trying to read beyond EOF, leave it unmapped */
692 if (map->m_la >= inode->i_size) {
693 map->m_llen = map->m_la + 1 - inode->i_size;
694 map->m_la = inode->i_size;
695 map->m_flags = 0;
696 goto out;
697 }
698
699 err = z_erofs_fill_inode_lazy(inode);
700 if (err)
701 goto out;
702
703 if ((vi->z_advise & Z_EROFS_ADVISE_FRAGMENT_PCLUSTER) &&
704 !vi->z_tailextent_headlcn) {
705 map->m_la = 0;
706 map->m_llen = inode->i_size;
707 map->m_flags = EROFS_MAP_MAPPED | EROFS_MAP_FULL_MAPPED |
708 EROFS_MAP_FRAGMENT;
709 goto out;
710 }
711
712 err = z_erofs_do_map_blocks(inode, map, flags);
713 out:
714 if (err)
715 map->m_llen = 0;
716 trace_erofs_map_blocks_exit(inode, map, flags, err);
717 return err;
718 }
719
720 static int z_erofs_iomap_begin_report(struct inode *inode, loff_t offset,
721 loff_t length, unsigned int flags,
722 struct iomap *iomap, struct iomap *srcmap)
723 {
724 int ret;
725 struct erofs_map_blocks map = { .m_la = offset };
726
727 ret = z_erofs_map_blocks_iter(inode, &map, EROFS_GET_BLOCKS_FIEMAP);
728 erofs_put_metabuf(&map.buf);
729 if (ret < 0)
730 return ret;
731
732 iomap->bdev = inode->i_sb->s_bdev;
733 iomap->offset = map.m_la;
734 iomap->length = map.m_llen;
735 if (map.m_flags & EROFS_MAP_MAPPED) {
736 iomap->type = IOMAP_MAPPED;
737 iomap->addr = map.m_flags & EROFS_MAP_FRAGMENT ?
738 IOMAP_NULL_ADDR : map.m_pa;
739 } else {
740 iomap->type = IOMAP_HOLE;
741 iomap->addr = IOMAP_NULL_ADDR;
742 /*
743 * No strict rule on how to describe extents for post EOF, yet
744 * we need to do like below. Otherwise, iomap itself will get
745 * into an endless loop on post EOF.
746 *
747 * Calculate the effective offset by subtracting extent start
748 * (map.m_la) from the requested offset, and add it to length.
749 * (NB: offset >= map.m_la always)
750 */
751 if (iomap->offset >= inode->i_size)
752 iomap->length = length + offset - map.m_la;
753 }
754 iomap->flags = 0;
755 return 0;
756 }
757
758 const struct iomap_ops z_erofs_iomap_report_ops = {
759 .iomap_begin = z_erofs_iomap_begin_report,
760 };
761
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.