1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Copyright (C) 2018-2019 HUAWEI, Inc. 4 * https://www.huawei.com/ 5 * Created by Gao Xiang <gaoxiang25@huawei.com> 6 */ 7#include "internal.h" 8#include <asm/unaligned.h> 9#include <trace/events/erofs.h> 10 11int z_erofs_fill_inode(struct inode *inode) 12{ 13 struct erofs_inode *const vi = EROFS_I(inode); 14 15 if (vi->datalayout == EROFS_INODE_FLAT_COMPRESSION_LEGACY) { 16 vi->z_advise = 0; 17 vi->z_algorithmtype[0] = 0; 18 vi->z_algorithmtype[1] = 0; 19 vi->z_logical_clusterbits = LOG_BLOCK_SIZE; 20 vi->z_physical_clusterbits[0] = vi->z_logical_clusterbits; 21 vi->z_physical_clusterbits[1] = vi->z_logical_clusterbits; 22 set_bit(EROFS_I_Z_INITED_BIT, &vi->flags); 23 } 24 25 inode->i_mapping->a_ops = &z_erofs_aops; 26 return 0; 27} 28 29static int z_erofs_fill_inode_lazy(struct inode *inode) 30{ 31 struct erofs_inode *const vi = EROFS_I(inode); 32 struct super_block *const sb = inode->i_sb; 33 int err; 34 erofs_off_t pos; 35 struct page *page; 36 void *kaddr; 37 struct z_erofs_map_header *h; 38 39 if (test_bit(EROFS_I_Z_INITED_BIT, &vi->flags)) { 40 /* 41 * paired with smp_mb() at the end of the function to ensure 42 * fields will only be observed after the bit is set. 43 */ 44 smp_mb(); 45 return 0; 46 } 47 48 if (wait_on_bit_lock(&vi->flags, EROFS_I_BL_Z_BIT, TASK_KILLABLE)) 49 return -ERESTARTSYS; 50 51 err = 0; 52 if (test_bit(EROFS_I_Z_INITED_BIT, &vi->flags)) 53 goto out_unlock; 54 55 DBG_BUGON(vi->datalayout == EROFS_INODE_FLAT_COMPRESSION_LEGACY); 56 57 pos = ALIGN(iloc(EROFS_SB(sb), vi->nid) + vi->inode_isize + 58 vi->xattr_isize, 8); 59 page = erofs_get_meta_page(sb, erofs_blknr(pos)); 60 if (IS_ERR(page)) { 61 err = PTR_ERR(page); 62 goto out_unlock; 63 } 64 65 kaddr = kmap_atomic(page); 66 67 h = kaddr + erofs_blkoff(pos); 68 vi->z_advise = le16_to_cpu(h->h_advise); 69 vi->z_algorithmtype[0] = h->h_algorithmtype & 15; 70 vi->z_algorithmtype[1] = h->h_algorithmtype >> 4; 71 72 if (vi->z_algorithmtype[0] >= Z_EROFS_COMPRESSION_MAX) { 73 erofs_err(sb, "unknown compression format %u for nid %llu, please upgrade kernel", 74 vi->z_algorithmtype[0], vi->nid); 75 err = -EOPNOTSUPP; 76 goto unmap_done; 77 } 78 79 vi->z_logical_clusterbits = LOG_BLOCK_SIZE + (h->h_clusterbits & 7); 80 vi->z_physical_clusterbits[0] = vi->z_logical_clusterbits + 81 ((h->h_clusterbits >> 3) & 3); 82 83 if (vi->z_physical_clusterbits[0] != LOG_BLOCK_SIZE) { 84 erofs_err(sb, "unsupported physical clusterbits %u for nid %llu, please upgrade kernel", 85 vi->z_physical_clusterbits[0], vi->nid); 86 err = -EOPNOTSUPP; 87 goto unmap_done; 88 } 89 90 vi->z_physical_clusterbits[1] = vi->z_logical_clusterbits + 91 ((h->h_clusterbits >> 5) & 7); 92 /* paired with smp_mb() at the beginning of the function */ 93 smp_mb(); 94 set_bit(EROFS_I_Z_INITED_BIT, &vi->flags); 95unmap_done: 96 kunmap_atomic(kaddr); 97 unlock_page(page); 98 put_page(page); 99out_unlock: 100 clear_and_wake_up_bit(EROFS_I_BL_Z_BIT, &vi->flags); 101 return err; 102} 103 104struct z_erofs_maprecorder { 105 struct inode *inode; 106 struct erofs_map_blocks *map; 107 void *kaddr; 108 109 unsigned long lcn; 110 /* compression extent information gathered */ 111 u8 type; 112 u16 clusterofs; 113 u16 delta[2]; 114 erofs_blk_t pblk; 115}; 116 117static int z_erofs_reload_indexes(struct z_erofs_maprecorder *m, 118 erofs_blk_t eblk) 119{ 120 struct super_block *const sb = m->inode->i_sb; 121 struct erofs_map_blocks *const map = m->map; 122 struct page *mpage = map->mpage; 123 124 if (mpage) { 125 if (mpage->index == eblk) { 126 if (!m->kaddr) 127 m->kaddr = kmap_atomic(mpage); 128 return 0; 129 } 130 131 if (m->kaddr) { 132 kunmap_atomic(m->kaddr); 133 m->kaddr = NULL; 134 } 135 put_page(mpage); 136 } 137 138 mpage = erofs_get_meta_page(sb, eblk); 139 if (IS_ERR(mpage)) { 140 map->mpage = NULL; 141 return PTR_ERR(mpage); 142 } 143 m->kaddr = kmap_atomic(mpage); 144 unlock_page(mpage); 145 map->mpage = mpage; 146 return 0; 147} 148 149static int legacy_load_cluster_from_disk(struct z_erofs_maprecorder *m, 150 unsigned long lcn) 151{ 152 struct inode *const inode = m->inode; 153 struct erofs_inode *const vi = EROFS_I(inode); 154 const erofs_off_t ibase = iloc(EROFS_I_SB(inode), vi->nid); 155 const erofs_off_t pos = 156 Z_EROFS_VLE_LEGACY_INDEX_ALIGN(ibase + vi->inode_isize + 157 vi->xattr_isize) + 158 lcn * sizeof(struct z_erofs_vle_decompressed_index); 159 struct z_erofs_vle_decompressed_index *di; 160 unsigned int advise, type; 161 int err; 162 163 err = z_erofs_reload_indexes(m, erofs_blknr(pos)); 164 if (err) 165 return err; 166 167 m->lcn = lcn; 168 di = m->kaddr + erofs_blkoff(pos); 169 170 advise = le16_to_cpu(di->di_advise); 171 type = (advise >> Z_EROFS_VLE_DI_CLUSTER_TYPE_BIT) & 172 ((1 << Z_EROFS_VLE_DI_CLUSTER_TYPE_BITS) - 1); 173 switch (type) { 174 case Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD: 175 m->clusterofs = 1 << vi->z_logical_clusterbits; 176 m->delta[0] = le16_to_cpu(di->di_u.delta[0]); 177 m->delta[1] = le16_to_cpu(di->di_u.delta[1]); 178 break; 179 case Z_EROFS_VLE_CLUSTER_TYPE_PLAIN: 180 case Z_EROFS_VLE_CLUSTER_TYPE_HEAD: 181 m->clusterofs = le16_to_cpu(di->di_clusterofs); 182 if (m->clusterofs >= 1 << vi->z_logical_clusterbits) { 183 DBG_BUGON(1); 184 return -EFSCORRUPTED; 185 } 186 m->pblk = le32_to_cpu(di->di_u.blkaddr); 187 break; 188 default: 189 DBG_BUGON(1); 190 return -EOPNOTSUPP; 191 } 192 m->type = type; 193 return 0; 194} 195 196static unsigned int decode_compactedbits(unsigned int lobits, 197 unsigned int lomask, 198 u8 *in, unsigned int pos, u8 *type) 199{ 200 const unsigned int v = get_unaligned_le32(in + pos / 8) >> (pos & 7); 201 const unsigned int lo = v & lomask; 202 203 *type = (v >> lobits) & 3; 204 return lo; 205} 206 207static int unpack_compacted_index(struct z_erofs_maprecorder *m, 208 unsigned int amortizedshift, 209 unsigned int eofs) 210{ 211 struct erofs_inode *const vi = EROFS_I(m->inode); 212 const unsigned int lclusterbits = vi->z_logical_clusterbits; 213 const unsigned int lomask = (1 << lclusterbits) - 1; 214 unsigned int vcnt, base, lo, encodebits, nblk; 215 int i; 216 u8 *in, type; 217 218 if (1 << amortizedshift == 4 && lclusterbits <= 14) 219 vcnt = 2; 220 else if (1 << amortizedshift == 2 && lclusterbits == 12) 221 vcnt = 16; 222 else 223 return -EOPNOTSUPP; 224 225 encodebits = ((vcnt << amortizedshift) - sizeof(__le32)) * 8 / vcnt; 226 base = round_down(eofs, vcnt << amortizedshift); 227 in = m->kaddr + base; 228 229 i = (eofs - base) >> amortizedshift; 230 231 lo = decode_compactedbits(lclusterbits, lomask, 232 in, encodebits * i, &type); 233 m->type = type; 234 if (type == Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD) { 235 m->clusterofs = 1 << lclusterbits; 236 if (i + 1 != vcnt) { 237 m->delta[0] = lo; 238 return 0; 239 } 240 /* 241 * since the last lcluster in the pack is special, 242 * of which lo saves delta[1] rather than delta[0]. 243 * Hence, get delta[0] by the previous lcluster indirectly. 244 */ 245 lo = decode_compactedbits(lclusterbits, lomask, 246 in, encodebits * (i - 1), &type); 247 if (type != Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD) 248 lo = 0; 249 m->delta[0] = lo + 1; 250 return 0; 251 } 252 m->clusterofs = lo; 253 m->delta[0] = 0; 254 /* figout out blkaddr (pblk) for HEAD lclusters */ 255 nblk = 1; 256 while (i > 0) { 257 --i; 258 lo = decode_compactedbits(lclusterbits, lomask, 259 in, encodebits * i, &type); 260 if (type == Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD) 261 i -= lo; 262 263 if (i >= 0) 264 ++nblk; 265 } 266 in += (vcnt << amortizedshift) - sizeof(__le32); 267 m->pblk = le32_to_cpu(*(__le32 *)in) + nblk; 268 return 0; 269} 270 271static int compacted_load_cluster_from_disk(struct z_erofs_maprecorder *m, 272 unsigned long lcn) 273{ 274 struct inode *const inode = m->inode; 275 struct erofs_inode *const vi = EROFS_I(inode); 276 const erofs_off_t ebase = ALIGN(iloc(EROFS_I_SB(inode), vi->nid) + 277 vi->inode_isize + vi->xattr_isize, 8) + 278 sizeof(struct z_erofs_map_header); 279 const unsigned int totalidx = DIV_ROUND_UP(inode->i_size, EROFS_BLKSIZ); 280 unsigned int compacted_4b_initial, compacted_2b; 281 unsigned int amortizedshift; 282 erofs_off_t pos; 283 int err; 284 285 if (lcn >= totalidx) 286 return -EINVAL; 287 288 m->lcn = lcn; 289 /* used to align to 32-byte (compacted_2b) alignment */ 290 compacted_4b_initial = (32 - ebase % 32) / 4; 291 if (compacted_4b_initial == 32 / 4) 292 compacted_4b_initial = 0; 293 294 if (vi->z_advise & Z_EROFS_ADVISE_COMPACTED_2B) 295 compacted_2b = rounddown(totalidx - compacted_4b_initial, 16); 296 else 297 compacted_2b = 0; 298 299 pos = ebase; 300 if (lcn < compacted_4b_initial) { 301 amortizedshift = 2; 302 goto out; 303 } 304 pos += compacted_4b_initial * 4; 305 lcn -= compacted_4b_initial; 306 307 if (lcn < compacted_2b) { 308 amortizedshift = 1; 309 goto out; 310 } 311 pos += compacted_2b * 2; 312 lcn -= compacted_2b; 313 amortizedshift = 2; 314out: 315 pos += lcn * (1 << amortizedshift); 316 err = z_erofs_reload_indexes(m, erofs_blknr(pos)); 317 if (err) 318 return err; 319 return unpack_compacted_index(m, amortizedshift, erofs_blkoff(pos)); 320} 321 322static int z_erofs_load_cluster_from_disk(struct z_erofs_maprecorder *m, 323 unsigned int lcn) 324{ 325 const unsigned int datamode = EROFS_I(m->inode)->datalayout; 326 327 if (datamode == EROFS_INODE_FLAT_COMPRESSION_LEGACY) 328 return legacy_load_cluster_from_disk(m, lcn); 329 330 if (datamode == EROFS_INODE_FLAT_COMPRESSION) 331 return compacted_load_cluster_from_disk(m, lcn); 332 333 return -EINVAL; 334} 335 336static int z_erofs_extent_lookback(struct z_erofs_maprecorder *m, 337 unsigned int lookback_distance) 338{ 339 struct erofs_inode *const vi = EROFS_I(m->inode); 340 struct erofs_map_blocks *const map = m->map; 341 const unsigned int lclusterbits = vi->z_logical_clusterbits; 342 unsigned long lcn = m->lcn; 343 int err; 344 345 if (lcn < lookback_distance) { 346 erofs_err(m->inode->i_sb, 347 "bogus lookback distance @ nid %llu", vi->nid); 348 DBG_BUGON(1); 349 return -EFSCORRUPTED; 350 } 351 352 /* load extent head logical cluster if needed */ 353 lcn -= lookback_distance; 354 err = z_erofs_load_cluster_from_disk(m, lcn); 355 if (err) 356 return err; 357 358 switch (m->type) { 359 case Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD: 360 if (!m->delta[0]) { 361 erofs_err(m->inode->i_sb, 362 "invalid lookback distance 0 @ nid %llu", 363 vi->nid); 364 DBG_BUGON(1); 365 return -EFSCORRUPTED; 366 } 367 return z_erofs_extent_lookback(m, m->delta[0]); 368 case Z_EROFS_VLE_CLUSTER_TYPE_PLAIN: 369 map->m_flags &= ~EROFS_MAP_ZIPPED; 370 fallthrough; 371 case Z_EROFS_VLE_CLUSTER_TYPE_HEAD: 372 map->m_la = (lcn << lclusterbits) | m->clusterofs; 373 break; 374 default: 375 erofs_err(m->inode->i_sb, 376 "unknown type %u @ lcn %lu of nid %llu", 377 m->type, lcn, vi->nid); 378 DBG_BUGON(1); 379 return -EOPNOTSUPP; 380 } 381 return 0; 382} 383 384int z_erofs_map_blocks_iter(struct inode *inode, 385 struct erofs_map_blocks *map, 386 int flags) 387{ 388 struct erofs_inode *const vi = EROFS_I(inode); 389 struct z_erofs_maprecorder m = { 390 .inode = inode, 391 .map = map, 392 }; 393 int err = 0; 394 unsigned int lclusterbits, endoff; 395 unsigned long long ofs, end; 396 397 trace_z_erofs_map_blocks_iter_enter(inode, map, flags); 398 399 /* when trying to read beyond EOF, leave it unmapped */ 400 if (map->m_la >= inode->i_size) { 401 map->m_llen = map->m_la + 1 - inode->i_size; 402 map->m_la = inode->i_size; 403 map->m_flags = 0; 404 goto out; 405 } 406 407 err = z_erofs_fill_inode_lazy(inode); 408 if (err) 409 goto out; 410 411 lclusterbits = vi->z_logical_clusterbits; 412 ofs = map->m_la; 413 m.lcn = ofs >> lclusterbits; 414 endoff = ofs & ((1 << lclusterbits) - 1); 415 416 err = z_erofs_load_cluster_from_disk(&m, m.lcn); 417 if (err) 418 goto unmap_out; 419 420 map->m_flags = EROFS_MAP_ZIPPED; /* by default, compressed */ 421 end = (m.lcn + 1ULL) << lclusterbits; 422 423 switch (m.type) { 424 case Z_EROFS_VLE_CLUSTER_TYPE_PLAIN: 425 if (endoff >= m.clusterofs) 426 map->m_flags &= ~EROFS_MAP_ZIPPED; 427 fallthrough; 428 case Z_EROFS_VLE_CLUSTER_TYPE_HEAD: 429 if (endoff >= m.clusterofs) { 430 map->m_la = (m.lcn << lclusterbits) | m.clusterofs; 431 break; 432 } 433 /* m.lcn should be >= 1 if endoff < m.clusterofs */ 434 if (!m.lcn) { 435 erofs_err(inode->i_sb, 436 "invalid logical cluster 0 at nid %llu", 437 vi->nid); 438 err = -EFSCORRUPTED; 439 goto unmap_out; 440 } 441 end = (m.lcn << lclusterbits) | m.clusterofs; 442 map->m_flags |= EROFS_MAP_FULL_MAPPED; 443 m.delta[0] = 1; 444 fallthrough; 445 case Z_EROFS_VLE_CLUSTER_TYPE_NONHEAD: 446 /* get the correspoinding first chunk */ 447 err = z_erofs_extent_lookback(&m, m.delta[0]); 448 if (err) 449 goto unmap_out; 450 break; 451 default: 452 erofs_err(inode->i_sb, 453 "unknown type %u @ offset %llu of nid %llu", 454 m.type, ofs, vi->nid); 455 err = -EOPNOTSUPP; 456 goto unmap_out; 457 } 458 459 map->m_llen = end - map->m_la; 460 map->m_plen = 1 << lclusterbits; 461 map->m_pa = blknr_to_addr(m.pblk); 462 map->m_flags |= EROFS_MAP_MAPPED; 463 464unmap_out: 465 if (m.kaddr) 466 kunmap_atomic(m.kaddr); 467 468out: 469 erofs_dbg("%s, m_la %llu m_pa %llu m_llen %llu m_plen %llu m_flags 0%o", 470 __func__, map->m_la, map->m_pa, 471 map->m_llen, map->m_plen, map->m_flags); 472 473 trace_z_erofs_map_blocks_iter_exit(inode, map, flags, err); 474 475 /* aggressively BUG_ON iff CONFIG_EROFS_FS_DEBUG is on */ 476 DBG_BUGON(err < 0 && err != -ENOMEM); 477 return err; 478} 479 480