Hi Kirill, [FYI, it's a private test report for your RFC patch.] [auto build test ERROR on block/for-next] [also build test ERROR on linus/master v5.5-rc1 next-20191210] [cannot apply to ext4/dev] [if your patch is applied to the wrong git tree, please drop us a note to help improve the system. BTW, we also suggest to use '--base' option to specify the base tree in git format-patch, please see https://stackoverflow.com/a/37406982] url: https://github.com/0day-ci/linux/commits/Kirill-Tkhai/block-ext4-Introduce-REQ_OP_ASSIGN_RANGE-to-reflect-extents-allocation-in-block-device-internals/20191211-073400 base: https://git.kernel.org/pub/scm/linux/kernel/git/axboe/linux-block.git for-next config: riscv-defconfig (attached as .config) compiler: riscv64-linux-gcc (GCC) 7.5.0 reproduce: wget https://raw.githubusercontent.com/intel/lkp-tests/master/sbin/make.cross -O ~/bin/make.cross chmod +x ~/bin/make.cross # save the attached .config to linux build tree GCC_VERSION=7.5.0 make.cross ARCH=riscv If you fix the issue, kindly add following tag Reported-by: kbuild test robot All errors (new ones prefixed by >>): fs/ext4/extents.c: In function 'ext4_ext_map_blocks': >> fs/ext4/extents.c:4493:51: error: 'struct ext4_sb_info' has no member named 'fallocate' if ((flags & EXT4_GET_BLOCKS_SUBMIT_ALLOC) && sbi->fallocate) { ^~ vim +4493 fs/ext4/extents.c 4261 4262 4263 /* 4264 * Block allocation/map/preallocation routine for extents based files 4265 * 4266 * 4267 * Need to be called with 4268 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block 4269 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem) 4270 * 4271 * return > 0, number of of blocks already mapped/allocated 4272 * if create == 0 and these are pre-allocated blocks 4273 * buffer head is unmapped 4274 * otherwise blocks are mapped 4275 * 4276 * return = 0, if plain look up failed (blocks have not been allocated) 4277 * buffer head is unmapped 4278 * 4279 * return < 0, error case. 4280 */ 4281 int ext4_ext_map_blocks(handle_t *handle, struct inode *inode, 4282 struct ext4_map_blocks *map, int flags) 4283 { 4284 struct ext4_ext_path *path = NULL; 4285 struct ext4_extent newex, *ex, *ex2; 4286 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb); 4287 ext4_fsblk_t newblock = 0; 4288 int free_on_err = 0, err = 0, depth, ret; 4289 unsigned int allocated = 0, offset = 0; 4290 unsigned int allocated_clusters = 0; 4291 struct ext4_allocation_request ar; 4292 ext4_lblk_t cluster_offset; 4293 bool map_from_cluster = false; 4294 4295 ext_debug("blocks %u/%u requested for inode %lu\n", 4296 map->m_lblk, map->m_len, inode->i_ino); 4297 trace_ext4_ext_map_blocks_enter(inode, map->m_lblk, map->m_len, flags); 4298 4299 /* find extent for this block */ 4300 path = ext4_find_extent(inode, map->m_lblk, NULL, 0); 4301 if (IS_ERR(path)) { 4302 err = PTR_ERR(path); 4303 path = NULL; 4304 goto out2; 4305 } 4306 4307 depth = ext_depth(inode); 4308 4309 /* 4310 * consistent leaf must not be empty; 4311 * this situation is possible, though, _during_ tree modification; 4312 * this is why assert can't be put in ext4_find_extent() 4313 */ 4314 if (unlikely(path[depth].p_ext == NULL && depth != 0)) { 4315 EXT4_ERROR_INODE(inode, "bad extent address " 4316 "lblock: %lu, depth: %d pblock %lld", 4317 (unsigned long) map->m_lblk, depth, 4318 path[depth].p_block); 4319 err = -EFSCORRUPTED; 4320 goto out2; 4321 } 4322 4323 ex = path[depth].p_ext; 4324 if (ex) { 4325 ext4_lblk_t ee_block = le32_to_cpu(ex->ee_block); 4326 ext4_fsblk_t ee_start = ext4_ext_pblock(ex); 4327 unsigned short ee_len; 4328 4329 4330 /* 4331 * unwritten extents are treated as holes, except that 4332 * we split out initialized portions during a write. 4333 */ 4334 ee_len = ext4_ext_get_actual_len(ex); 4335 4336 trace_ext4_ext_show_extent(inode, ee_block, ee_start, ee_len); 4337 4338 /* if found extent covers block, simply return it */ 4339 if (in_range(map->m_lblk, ee_block, ee_len)) { 4340 newblock = map->m_lblk - ee_block + ee_start; 4341 /* number of remaining blocks in the extent */ 4342 allocated = ee_len - (map->m_lblk - ee_block); 4343 ext_debug("%u fit into %u:%d -> %llu\n", map->m_lblk, 4344 ee_block, ee_len, newblock); 4345 4346 /* 4347 * If the extent is initialized check whether the 4348 * caller wants to convert it to unwritten. 4349 */ 4350 if ((!ext4_ext_is_unwritten(ex)) && 4351 (flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN)) { 4352 allocated = convert_initialized_extent( 4353 handle, inode, map, &path, 4354 allocated); 4355 goto out2; 4356 } else if (!ext4_ext_is_unwritten(ex)) 4357 goto out; 4358 4359 ret = ext4_ext_handle_unwritten_extents( 4360 handle, inode, map, &path, flags, 4361 allocated, newblock); 4362 if (ret < 0) 4363 err = ret; 4364 else 4365 allocated = ret; 4366 goto out2; 4367 } 4368 } 4369 4370 /* 4371 * requested block isn't allocated yet; 4372 * we couldn't try to create block if create flag is zero 4373 */ 4374 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0) { 4375 ext4_lblk_t hole_start, hole_len; 4376 4377 hole_start = map->m_lblk; 4378 hole_len = ext4_ext_determine_hole(inode, path, &hole_start); 4379 /* 4380 * put just found gap into cache to speed up 4381 * subsequent requests 4382 */ 4383 ext4_ext_put_gap_in_cache(inode, hole_start, hole_len); 4384 4385 /* Update hole_len to reflect hole size after map->m_lblk */ 4386 if (hole_start != map->m_lblk) 4387 hole_len -= map->m_lblk - hole_start; 4388 map->m_pblk = 0; 4389 map->m_len = min_t(unsigned int, map->m_len, hole_len); 4390 4391 goto out2; 4392 } 4393 4394 /* 4395 * Okay, we need to do block allocation. 4396 */ 4397 newex.ee_block = cpu_to_le32(map->m_lblk); 4398 cluster_offset = EXT4_LBLK_COFF(sbi, map->m_lblk); 4399 4400 /* 4401 * If we are doing bigalloc, check to see if the extent returned 4402 * by ext4_find_extent() implies a cluster we can use. 4403 */ 4404 if (cluster_offset && ex && 4405 get_implied_cluster_alloc(inode->i_sb, map, ex, path)) { 4406 ar.len = allocated = map->m_len; 4407 newblock = map->m_pblk; 4408 map_from_cluster = true; 4409 goto got_allocated_blocks; 4410 } 4411 4412 /* find neighbour allocated blocks */ 4413 ar.lleft = map->m_lblk; 4414 err = ext4_ext_search_left(inode, path, &ar.lleft, &ar.pleft); 4415 if (err) 4416 goto out2; 4417 ar.lright = map->m_lblk; 4418 ex2 = NULL; 4419 err = ext4_ext_search_right(inode, path, &ar.lright, &ar.pright, &ex2); 4420 if (err) 4421 goto out2; 4422 4423 /* Check if the extent after searching to the right implies a 4424 * cluster we can use. */ 4425 if ((sbi->s_cluster_ratio > 1) && ex2 && 4426 get_implied_cluster_alloc(inode->i_sb, map, ex2, path)) { 4427 ar.len = allocated = map->m_len; 4428 newblock = map->m_pblk; 4429 map_from_cluster = true; 4430 goto got_allocated_blocks; 4431 } 4432 4433 /* 4434 * See if request is beyond maximum number of blocks we can have in 4435 * a single extent. For an initialized extent this limit is 4436 * EXT_INIT_MAX_LEN and for an unwritten extent this limit is 4437 * EXT_UNWRITTEN_MAX_LEN. 4438 */ 4439 if (map->m_len > EXT_INIT_MAX_LEN && 4440 !(flags & EXT4_GET_BLOCKS_UNWRIT_EXT)) 4441 map->m_len = EXT_INIT_MAX_LEN; 4442 else if (map->m_len > EXT_UNWRITTEN_MAX_LEN && 4443 (flags & EXT4_GET_BLOCKS_UNWRIT_EXT)) 4444 map->m_len = EXT_UNWRITTEN_MAX_LEN; 4445 4446 /* Check if we can really insert (m_lblk)::(m_lblk + m_len) extent */ 4447 newex.ee_len = cpu_to_le16(map->m_len); 4448 err = ext4_ext_check_overlap(sbi, inode, &newex, path); 4449 if (err) 4450 allocated = ext4_ext_get_actual_len(&newex); 4451 else 4452 allocated = map->m_len; 4453 4454 /* allocate new block */ 4455 ar.inode = inode; 4456 ar.goal = ext4_ext_find_goal(inode, path, map->m_lblk); 4457 ar.logical = map->m_lblk; 4458 /* 4459 * We calculate the offset from the beginning of the cluster 4460 * for the logical block number, since when we allocate a 4461 * physical cluster, the physical block should start at the 4462 * same offset from the beginning of the cluster. This is 4463 * needed so that future calls to get_implied_cluster_alloc() 4464 * work correctly. 4465 */ 4466 offset = EXT4_LBLK_COFF(sbi, map->m_lblk); 4467 ar.len = EXT4_NUM_B2C(sbi, offset+allocated); 4468 ar.goal -= offset; 4469 ar.logical -= offset; 4470 if (S_ISREG(inode->i_mode)) 4471 ar.flags = EXT4_MB_HINT_DATA; 4472 else 4473 /* disable in-core preallocation for non-regular files */ 4474 ar.flags = 0; 4475 if (flags & EXT4_GET_BLOCKS_NO_NORMALIZE) 4476 ar.flags |= EXT4_MB_HINT_NOPREALLOC; 4477 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) 4478 ar.flags |= EXT4_MB_DELALLOC_RESERVED; 4479 if (flags & EXT4_GET_BLOCKS_METADATA_NOFAIL) 4480 ar.flags |= EXT4_MB_USE_RESERVED; 4481 newblock = ext4_mb_new_blocks(handle, &ar, &err); 4482 if (!newblock) 4483 goto out2; 4484 ext_debug("allocate new block: goal %llu, found %llu/%u\n", 4485 ar.goal, newblock, allocated); 4486 free_on_err = 1; 4487 allocated_clusters = ar.len; 4488 ar.len = EXT4_C2B(sbi, ar.len) - offset; 4489 if (ar.len > allocated) 4490 ar.len = allocated; 4491 4492 got_allocated_blocks: > 4493 if ((flags & EXT4_GET_BLOCKS_SUBMIT_ALLOC) && sbi->fallocate) { 4494 err = sb_issue_assign_range(inode->i_sb, newblock, 4495 EXT4_C2B(sbi, allocated_clusters), GFP_NOFS); 4496 if (err) 4497 goto free_on_err; 4498 } 4499 4500 /* try to insert new extent into found leaf and return */ 4501 ext4_ext_store_pblock(&newex, newblock + offset); 4502 newex.ee_len = cpu_to_le16(ar.len); 4503 /* Mark unwritten */ 4504 if (flags & EXT4_GET_BLOCKS_UNWRIT_EXT){ 4505 ext4_ext_mark_unwritten(&newex); 4506 map->m_flags |= EXT4_MAP_UNWRITTEN; 4507 } 4508 4509 err = 0; 4510 if ((flags & EXT4_GET_BLOCKS_KEEP_SIZE) == 0) 4511 err = check_eofblocks_fl(handle, inode, map->m_lblk, 4512 path, ar.len); 4513 if (!err) 4514 err = ext4_ext_insert_extent(handle, inode, &path, 4515 &newex, flags); 4516 free_on_err: 4517 if (err && free_on_err) { 4518 int fb_flags = flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE ? 4519 EXT4_FREE_BLOCKS_NO_QUOT_UPDATE : 0; 4520 /* free data blocks we just allocated */ 4521 /* not a good idea to call discard here directly, 4522 * but otherwise we'd need to call it every free() */ 4523 ext4_discard_preallocations(inode); 4524 ext4_free_blocks(handle, inode, NULL, newblock, 4525 EXT4_C2B(sbi, allocated_clusters), fb_flags); 4526 goto out2; 4527 } 4528 4529 /* previous routine could use block we allocated */ 4530 newblock = ext4_ext_pblock(&newex); 4531 allocated = ext4_ext_get_actual_len(&newex); 4532 if (allocated > map->m_len) 4533 allocated = map->m_len; 4534 map->m_flags |= EXT4_MAP_NEW; 4535 4536 /* 4537 * Reduce the reserved cluster count to reflect successful deferred 4538 * allocation of delayed allocated clusters or direct allocation of 4539 * clusters discovered to be delayed allocated. Once allocated, a 4540 * cluster is not included in the reserved count. 4541 */ 4542 if (test_opt(inode->i_sb, DELALLOC) && !map_from_cluster) { 4543 if (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) { 4544 /* 4545 * When allocating delayed allocated clusters, simply 4546 * reduce the reserved cluster count and claim quota 4547 */ 4548 ext4_da_update_reserve_space(inode, allocated_clusters, 4549 1); 4550 } else { 4551 ext4_lblk_t lblk, len; 4552 unsigned int n; 4553 4554 /* 4555 * When allocating non-delayed allocated clusters 4556 * (from fallocate, filemap, DIO, or clusters 4557 * allocated when delalloc has been disabled by 4558 * ext4_nonda_switch), reduce the reserved cluster 4559 * count by the number of allocated clusters that 4560 * have previously been delayed allocated. Quota 4561 * has been claimed by ext4_mb_new_blocks() above, 4562 * so release the quota reservations made for any 4563 * previously delayed allocated clusters. 4564 */ 4565 lblk = EXT4_LBLK_CMASK(sbi, map->m_lblk); 4566 len = allocated_clusters << sbi->s_cluster_bits; 4567 n = ext4_es_delayed_clu(inode, lblk, len); 4568 if (n > 0) 4569 ext4_da_update_reserve_space(inode, (int) n, 0); 4570 } 4571 } 4572 4573 /* 4574 * Cache the extent and update transaction to commit on fdatasync only 4575 * when it is _not_ an unwritten extent. 4576 */ 4577 if ((flags & EXT4_GET_BLOCKS_UNWRIT_EXT) == 0) 4578 ext4_update_inode_fsync_trans(handle, inode, 1); 4579 else 4580 ext4_update_inode_fsync_trans(handle, inode, 0); 4581 out: 4582 if (allocated > map->m_len) 4583 allocated = map->m_len; 4584 ext4_ext_show_leaf(inode, path); 4585 map->m_flags |= EXT4_MAP_MAPPED; 4586 map->m_pblk = newblock; 4587 map->m_len = allocated; 4588 out2: 4589 ext4_ext_drop_refs(path); 4590 kfree(path); 4591 4592 trace_ext4_ext_map_blocks_exit(inode, flags, map, 4593 err ? err : allocated); 4594 return err ? err : allocated; 4595 } 4596 --- 0-DAY kernel test infrastructure Open Source Technology Center https://lists.01.org/hyperkitty/list/kbuild-all(a)lists.01.org Intel Corporation