| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <202502161654.6egvP8G4-lkp@intel.com>
Date: Sun, 16 Feb 2025 16:36:28 +0800
From: kernel test robot <lkp@...el.com>
To: Mikulas Patocka <mpatocka@...hat.com>
Cc: oe-kbuild-all@...ts.linux.dev, linux-kernel@...r.kernel.org,
Mike Snitzer <snitzer@...nel.org>
Subject: drivers/md/dm-integrity.c:2470 dm_integrity_map_inline() warn:
unsigned '_x' is never less than zero.
tree: https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git master
head: ad1b832bf1cf2df9304f8eb72943111625c7e5a7
commit: fb0987682c629c1d2c476f35f6fde405a5e304a4 dm-integrity: introduce the Inline mode
date: 7 months ago
config: riscv-randconfig-r073-20250213 (https://download.01.org/0day-ci/archive/20250216/202502161654.6egvP8G4-lkp@intel.com/config)
compiler: riscv32-linux-gcc (GCC) 14.2.0
If you fix the issue in a separate patch/commit (i.e. not just a new version of
the same patch/commit), kindly add following tags
| Reported-by: kernel test robot <lkp@...el.com>
| Closes: https://lore.kernel.org/oe-kbuild-all/202502161654.6egvP8G4-lkp@intel.com/
New smatch warnings:
drivers/md/dm-integrity.c:2470 dm_integrity_map_inline() warn: unsigned '_x' is never less than zero.
drivers/md/dm-integrity.c:2514 dm_integrity_inline_recheck() warn: unsigned '_x' is never less than zero.
drivers/md/dm-integrity.c:2485 dm_integrity_free_payload() warn: unsigned '_x' is never less than zero.
Old smatch warnings:
drivers/md/dm-integrity.c:515 sb_mac() error: memcmp() 'actual_mac' too small (64 vs 448)
drivers/md/dm-integrity.c:2530 dm_integrity_inline_recheck() warn: unsigned '_x' is never less than zero.
include/linux/scatterlist.h:189 sg_set_buf() warn: unsigned '_x' is never less than zero.
drivers/md/dm-integrity.c:4718 dm_integrity_ctr() warn: add some parenthesis here?
drivers/md/dm-integrity.c:4941 dm_integrity_ctr() warn: Function too hairy. No more merges.
vim +/_x +2470 drivers/md/dm-integrity.c
2397
2398 static int dm_integrity_map_inline(struct dm_integrity_io *dio)
2399 {
2400 struct dm_integrity_c *ic = dio->ic;
2401 struct bio *bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));
2402 struct bio_integrity_payload *bip;
2403 unsigned payload_len, digest_size, extra_size, ret;
2404
2405 dio->integrity_payload = NULL;
2406 dio->integrity_payload_from_mempool = false;
2407
2408 if (unlikely(bio_integrity(bio))) {
2409 bio->bi_status = BLK_STS_NOTSUPP;
2410 bio_endio(bio);
2411 return DM_MAPIO_SUBMITTED;
2412 }
2413
2414 bio_set_dev(bio, ic->dev->bdev);
2415 if (unlikely((bio->bi_opf & REQ_PREFLUSH) != 0))
2416 return DM_MAPIO_REMAPPED;
2417
2418 retry:
2419 payload_len = ic->tuple_size * (bio_sectors(bio) >> ic->sb->log2_sectors_per_block);
2420 digest_size = crypto_shash_digestsize(ic->internal_hash);
2421 extra_size = unlikely(digest_size > ic->tag_size) ? digest_size - ic->tag_size : 0;
2422 payload_len += extra_size;
2423 dio->integrity_payload = kmalloc(payload_len, GFP_NOIO | __GFP_NORETRY | __GFP_NOMEMALLOC | __GFP_NOWARN);
2424 if (unlikely(!dio->integrity_payload)) {
2425 const unsigned x_size = PAGE_SIZE << 1;
2426 if (payload_len > x_size) {
2427 unsigned sectors = ((x_size - extra_size) / ic->tuple_size) << ic->sb->log2_sectors_per_block;
2428 if (WARN_ON(!sectors || sectors >= bio_sectors(bio))) {
2429 bio->bi_status = BLK_STS_NOTSUPP;
2430 bio_endio(bio);
2431 return DM_MAPIO_SUBMITTED;
2432 }
2433 dm_accept_partial_bio(bio, sectors);
2434 goto retry;
2435 }
2436 dio->integrity_payload = page_to_virt((struct page *)mempool_alloc(&ic->recheck_pool, GFP_NOIO));
2437 dio->integrity_payload_from_mempool = true;
2438 }
2439
2440 bio->bi_iter.bi_sector = dm_target_offset(ic->ti, bio->bi_iter.bi_sector);
2441 dio->bio_details.bi_iter = bio->bi_iter;
2442
2443 if (unlikely(!dm_integrity_check_limits(ic, bio->bi_iter.bi_sector, bio))) {
2444 return DM_MAPIO_KILL;
2445 }
2446
2447 bio->bi_iter.bi_sector += ic->start + SB_SECTORS;
2448
2449 bip = bio_integrity_alloc(bio, GFP_NOIO, 1);
2450 if (unlikely(IS_ERR(bip))) {
2451 bio->bi_status = errno_to_blk_status(PTR_ERR(bip));
2452 bio_endio(bio);
2453 return DM_MAPIO_SUBMITTED;
2454 }
2455
2456 if (dio->op == REQ_OP_WRITE) {
2457 unsigned pos = 0;
2458 while (dio->bio_details.bi_iter.bi_size) {
2459 struct bio_vec bv = bio_iter_iovec(bio, dio->bio_details.bi_iter);
2460 const char *mem = bvec_kmap_local(&bv);
2461 if (ic->tag_size < ic->tuple_size)
2462 memset(dio->integrity_payload + pos + ic->tag_size, 0, ic->tuple_size - ic->tuple_size);
2463 integrity_sector_checksum(ic, dio->bio_details.bi_iter.bi_sector, mem, dio->integrity_payload + pos);
2464 kunmap_local(mem);
2465 pos += ic->tuple_size;
2466 bio_advance_iter_single(bio, &dio->bio_details.bi_iter, ic->sectors_per_block << SECTOR_SHIFT);
2467 }
2468 }
2469
> 2470 ret = bio_integrity_add_page(bio, virt_to_page(dio->integrity_payload),
2471 payload_len, offset_in_page(dio->integrity_payload));
2472 if (unlikely(ret != payload_len)) {
2473 bio->bi_status = BLK_STS_RESOURCE;
2474 bio_endio(bio);
2475 return DM_MAPIO_SUBMITTED;
2476 }
2477
2478 return DM_MAPIO_REMAPPED;
2479 }
2480
2481 static inline void dm_integrity_free_payload(struct dm_integrity_io *dio)
2482 {
2483 struct dm_integrity_c *ic = dio->ic;
2484 if (unlikely(dio->integrity_payload_from_mempool))
> 2485 mempool_free(virt_to_page(dio->integrity_payload), &ic->recheck_pool);
2486 else
2487 kfree(dio->integrity_payload);
2488 dio->integrity_payload = NULL;
2489 dio->integrity_payload_from_mempool = false;
2490 }
2491
2492 static void dm_integrity_inline_recheck(struct work_struct *w)
2493 {
2494 struct dm_integrity_io *dio = container_of(w, struct dm_integrity_io, work);
2495 struct bio *bio = dm_bio_from_per_bio_data(dio, sizeof(struct dm_integrity_io));
2496 struct dm_integrity_c *ic = dio->ic;
2497 struct bio *outgoing_bio;
2498 void *outgoing_data;
2499
2500 dio->integrity_payload = page_to_virt((struct page *)mempool_alloc(&ic->recheck_pool, GFP_NOIO));
2501 dio->integrity_payload_from_mempool = true;
2502
2503 outgoing_data = dio->integrity_payload + PAGE_SIZE;
2504
2505 while (dio->bio_details.bi_iter.bi_size) {
2506 char digest[HASH_MAX_DIGESTSIZE];
2507 int r;
2508 struct bio_integrity_payload *bip;
2509 struct bio_vec bv;
2510 char *mem;
2511
2512 outgoing_bio = bio_alloc_bioset(ic->dev->bdev, 1, REQ_OP_READ, GFP_NOIO, &ic->recheck_bios);
2513
> 2514 r = bio_add_page(outgoing_bio, virt_to_page(outgoing_data), ic->sectors_per_block << SECTOR_SHIFT, 0);
2515 if (unlikely(r != (ic->sectors_per_block << SECTOR_SHIFT))) {
2516 bio_put(outgoing_bio);
2517 bio->bi_status = BLK_STS_RESOURCE;
2518 bio_endio(bio);
2519 return;
2520 }
2521
2522 bip = bio_integrity_alloc(outgoing_bio, GFP_NOIO, 1);
2523 if (unlikely(IS_ERR(bip))) {
2524 bio_put(outgoing_bio);
2525 bio->bi_status = errno_to_blk_status(PTR_ERR(bip));
2526 bio_endio(bio);
2527 return;
2528 }
2529
2530 r = bio_integrity_add_page(outgoing_bio, virt_to_page(dio->integrity_payload), ic->tuple_size, 0);
2531 if (unlikely(r != ic->tuple_size)) {
2532 bio_put(outgoing_bio);
2533 bio->bi_status = BLK_STS_RESOURCE;
2534 bio_endio(bio);
2535 return;
2536 }
2537
2538 outgoing_bio->bi_iter.bi_sector = dio->bio_details.bi_iter.bi_sector + ic->start + SB_SECTORS;
2539
2540 r = submit_bio_wait(outgoing_bio);
2541 if (unlikely(r != 0)) {
2542 bio_put(outgoing_bio);
2543 bio->bi_status = errno_to_blk_status(r);
2544 bio_endio(bio);
2545 return;
2546 }
2547 bio_put(outgoing_bio);
2548
2549 integrity_sector_checksum(ic, dio->bio_details.bi_iter.bi_sector, outgoing_data, digest);
2550 if (unlikely(memcmp(digest, dio->integrity_payload, min(crypto_shash_digestsize(ic->internal_hash), ic->tag_size)))) {
2551 DMERR_LIMIT("%pg: Checksum failed at sector 0x%llx",
2552 ic->dev->bdev, dio->bio_details.bi_iter.bi_sector);
2553 atomic64_inc(&ic->number_of_mismatches);
2554 dm_audit_log_bio(DM_MSG_PREFIX, "integrity-checksum",
2555 bio, dio->bio_details.bi_iter.bi_sector, 0);
2556
2557 bio->bi_status = BLK_STS_PROTECTION;
2558 bio_endio(bio);
2559 return;
2560 }
2561
2562 bv = bio_iter_iovec(bio, dio->bio_details.bi_iter);
2563 mem = bvec_kmap_local(&bv);
2564 memcpy(mem, outgoing_data, ic->sectors_per_block << SECTOR_SHIFT);
2565 kunmap_local(mem);
2566
2567 bio_advance_iter_single(bio, &dio->bio_details.bi_iter, ic->sectors_per_block << SECTOR_SHIFT);
2568 }
2569
2570 bio_endio(bio);
2571 }
2572
--
0-DAY CI Kernel Test Service
https://github.com/intel/lkp-tests/wiki
Powered by blists - more mailing lists