treewide: use get_random_u32_inclusive() when possible

These cases were done with this Coccinelle:

@@
expression H;
expression L;
@@
- (get_random_u32_below(H) + L)
+ get_random_u32_inclusive(L, H + L - 1)

@@
expression H;
expression L;
expression E;
@@
  get_random_u32_inclusive(L,
  H
- + E
- - E
  )

@@
expression H;
expression L;
expression E;
@@
  get_random_u32_inclusive(L,
  H
- - E
- + E
  )

@@
expression H;
expression L;
expression E;
expression F;
@@
  get_random_u32_inclusive(L,
  H
- - E
  + F
- + E
  )

@@
expression H;
expression L;
expression E;
expression F;
@@
  get_random_u32_inclusive(L,
  H
- + E
  + F
- - E
  )

And then subsequently cleaned up by hand, with several automatic cases
rejected if it didn't make sense contextually.

Reviewed-by: Kees Cook <keescook@chromium.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com> # for infiniband
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>

diff --git a/arch/x86/kernel/module.c b/arch/x86/kernel/module.c
index c09ae279ef32d6854c9350c1af53a736cce61262..a98687642dd01b60c4b7717b6b50e4dda7453166 100644 (file)
--- a/arch/x86/kernel/module.c
+++ b/arch/x86/kernel/module.c
@@ -53,7 +53,7 @@ static unsigned long int get_module_load_offset(void)
                 */
                if (module_load_offset == 0)
                        module_load_offset =
-                               (get_random_u32_below(1024) + 1) * PAGE_SIZE;
+                               get_random_u32_inclusive(1, 1024) * PAGE_SIZE;
                mutex_unlock(&module_kaslr_mutex);
        }
        return module_load_offset;

diff --git a/crypto/rsa-pkcs1pad.c b/crypto/rsa-pkcs1pad.c
index 0f722f8f779b7686f98b706cbd4f10960fdfe2c2..e75728f87ce5620ff2aa159f14fdc820492f414a 100644 (file)
--- a/crypto/rsa-pkcs1pad.c
+++ b/crypto/rsa-pkcs1pad.c
@@ -253,7 +253,7 @@ static int pkcs1pad_encrypt(struct akcipher_request *req)
        ps_end = ctx->key_size - req->src_len - 2;
        req_ctx->in_buf[0] = 0x02;
        for (i = 1; i < ps_end; i++)
-               req_ctx->in_buf[i] = 1 + get_random_u32_below(255);
+               req_ctx->in_buf[i] = get_random_u32_inclusive(1, 255);
        req_ctx->in_buf[ps_end] = 0x00;
 
        pkcs1pad_sg_set_buf(req_ctx->in_sg, req_ctx->in_buf,

diff --git a/crypto/testmgr.c b/crypto/testmgr.c
index 079923d43ce229042a4e7b955cf6549d62281d5d..e669acd2ebdd218d24164c9e3eace5503fe70dc5 100644 (file)
--- a/crypto/testmgr.c
+++ b/crypto/testmgr.c
@@ -962,11 +962,11 @@ static char *generate_random_sgl_divisions(struct test_sg_division *divs,
                if (div == &divs[max_divs - 1] || get_random_u32_below(2) == 0)
                        this_len = remaining;
                else
-                       this_len = 1 + get_random_u32_below(remaining);
+                       this_len = get_random_u32_inclusive(1, remaining);
                div->proportion_of_total = this_len;
 
                if (get_random_u32_below(4) == 0)
-                       div->offset = (PAGE_SIZE - 128) + get_random_u32_below(128);
+                       div->offset = get_random_u32_inclusive(PAGE_SIZE - 128, PAGE_SIZE - 1);
                else if (get_random_u32_below(2) == 0)
                        div->offset = get_random_u32_below(32);
                else
@@ -1094,12 +1094,12 @@ static void generate_random_testvec_config(struct testvec_config *cfg,
        }
 
        if (get_random_u32_below(2) == 0) {
-               cfg->iv_offset = 1 + get_random_u32_below(MAX_ALGAPI_ALIGNMASK);
+               cfg->iv_offset = get_random_u32_inclusive(1, MAX_ALGAPI_ALIGNMASK);
                p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset);
        }
 
        if (get_random_u32_below(2) == 0) {
-               cfg->key_offset = 1 + get_random_u32_below(MAX_ALGAPI_ALIGNMASK);
+               cfg->key_offset = get_random_u32_inclusive(1, MAX_ALGAPI_ALIGNMASK);
                p += scnprintf(p, end - p, " key_offset=%u", cfg->key_offset);
        }
 
@@ -1653,7 +1653,7 @@ static void generate_random_hash_testvec(struct shash_desc *desc,
        if (maxkeysize) {
                vec->ksize = maxkeysize;
                if (get_random_u32_below(4) == 0)
-                       vec->ksize = 1 + get_random_u32_below(maxkeysize);
+                       vec->ksize = get_random_u32_inclusive(1, maxkeysize);
                generate_random_bytes((u8 *)vec->key, vec->ksize);
 
                vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,

diff --git a/drivers/bus/mhi/host/internal.h b/drivers/bus/mhi/host/internal.h
index c73621aabbd1bf9eacb61b3111ce540ec4f76192..2e139e76de4c0375b3cf9d711097b3e97da50f24 100644 (file)
--- a/drivers/bus/mhi/host/internal.h
+++ b/drivers/bus/mhi/host/internal.h
@@ -129,7 +129,7 @@ enum mhi_pm_state {
 #define PRIMARY_CMD_RING                               0
 #define MHI_DEV_WAKE_DB                                        127
 #define MHI_MAX_MTU                                    0xffff
-#define MHI_RANDOM_U32_NONZERO(bmsk)                   (get_random_u32_below(bmsk) + 1)
+#define MHI_RANDOM_U32_NONZERO(bmsk)                   (get_random_u32_inclusive(1, bmsk))
 
 enum mhi_er_type {
        MHI_ER_TYPE_INVALID = 0x0,

diff --git a/drivers/dma-buf/st-dma-fence-chain.c b/drivers/dma-buf/st-dma-fence-chain.c
index 9fbad7317d9b275986df5dd8387215c527a7abe9..c0979c8049b5a3b071b90acceab1e70f51796ed4 100644 (file)
--- a/drivers/dma-buf/st-dma-fence-chain.c
+++ b/drivers/dma-buf/st-dma-fence-chain.c
@@ -400,7 +400,7 @@ static int __find_race(void *arg)
                struct dma_fence *fence = dma_fence_get(data->fc.tail);
                int seqno;
 
-               seqno = get_random_u32_below(data->fc.chain_length) + 1;
+               seqno = get_random_u32_inclusive(1, data->fc.chain_length);
 
                err = dma_fence_chain_find_seqno(&fence, seqno);
                if (err) {

diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index dd1c703b10df1c2b2406713b468ff71bc19bcecf..aacd6254df77aa73aac87ee6af66abace597a37f 100644 (file)
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -3807,7 +3807,7 @@ static int cma_alloc_any_port(enum rdma_ucm_port_space ps,
 
        inet_get_local_port_range(net, &low, &high);
        remaining = (high - low) + 1;
-       rover = get_random_u32_below(remaining) + low;
+       rover = get_random_u32_inclusive(low, remaining + low - 1);
 retry:
        if (last_used_port != rover) {
                struct rdma_bind_list *bind_list;

diff --git a/drivers/infiniband/hw/hns/hns_roce_ah.c b/drivers/infiniband/hw/hns/hns_roce_ah.c
index b37d2a81584d640d605c1a532c55f841493c63b3..e77fcc74f15c49a497329a9019246d613c96007f 100644 (file)
--- a/drivers/infiniband/hw/hns/hns_roce_ah.c
+++ b/drivers/infiniband/hw/hns/hns_roce_ah.c
@@ -41,9 +41,8 @@ static inline u16 get_ah_udp_sport(const struct rdma_ah_attr *ah_attr)
        u16 sport;
 
        if (!fl)
-               sport = get_random_u32_below(IB_ROCE_UDP_ENCAP_VALID_PORT_MAX +
-                                            1 - IB_ROCE_UDP_ENCAP_VALID_PORT_MIN) +
-                       IB_ROCE_UDP_ENCAP_VALID_PORT_MIN;
+               sport = get_random_u32_inclusive(IB_ROCE_UDP_ENCAP_VALID_PORT_MIN,
+                                                IB_ROCE_UDP_ENCAP_VALID_PORT_MAX);
        else
                sport = rdma_flow_label_to_udp_sport(fl);
 

diff --git a/drivers/mtd/nand/raw/nandsim.c b/drivers/mtd/nand/raw/nandsim.c
index 274a31b931003a4dcc1d3a425fda8ecf6bd4b847..c21abf7489481a5b230fc67b6361456eaa6e07a5 100644 (file)
--- a/drivers/mtd/nand/raw/nandsim.c
+++ b/drivers/mtd/nand/raw/nandsim.c
@@ -1405,7 +1405,7 @@ static void ns_do_bit_flips(struct nandsim *ns, int num)
        if (bitflips && get_random_u16() < (1 << 6)) {
                int flips = 1;
                if (bitflips > 1)
-                       flips = get_random_u32_below(bitflips) + 1;
+                       flips = get_random_u32_inclusive(1, bitflips);
                while (flips--) {
                        int pos = get_random_u32_below(num * 8);
                        ns->buf.byte[pos / 8] ^= (1 << (pos % 8));

diff --git a/drivers/net/wireguard/selftest/allowedips.c b/drivers/net/wireguard/selftest/allowedips.c
index 78a916f30c821679b54b5d23f285585abacd706a..78ebe2892a7886ca21c34c2fd7bab1be3024948f 100644 (file)
--- a/drivers/net/wireguard/selftest/allowedips.c
+++ b/drivers/net/wireguard/selftest/allowedips.c
@@ -285,7 +285,7 @@ static __init bool randomized_test(void)
 
        for (i = 0; i < NUM_RAND_ROUTES; ++i) {
                get_random_bytes(ip, 4);
-               cidr = get_random_u32_below(32) + 1;
+               cidr = get_random_u32_inclusive(1, 32);
                peer = peers[get_random_u32_below(NUM_PEERS)];
                if (wg_allowedips_insert_v4(&t, (struct in_addr *)ip, cidr,
                                            peer, &mutex) < 0) {
@@ -311,7 +311,7 @@ static __init bool randomized_test(void)
                                mutated[k] = (mutated[k] & mutate_mask[k]) |
                                             (~mutate_mask[k] &
                                              get_random_u8());
-                       cidr = get_random_u32_below(32) + 1;
+                       cidr = get_random_u32_inclusive(1, 32);
                        peer = peers[get_random_u32_below(NUM_PEERS)];
                        if (wg_allowedips_insert_v4(&t,
                                                    (struct in_addr *)mutated,
@@ -329,7 +329,7 @@ static __init bool randomized_test(void)
 
        for (i = 0; i < NUM_RAND_ROUTES; ++i) {
                get_random_bytes(ip, 16);
-               cidr = get_random_u32_below(128) + 1;
+               cidr = get_random_u32_inclusive(1, 128);
                peer = peers[get_random_u32_below(NUM_PEERS)];
                if (wg_allowedips_insert_v6(&t, (struct in6_addr *)ip, cidr,
                                            peer, &mutex) < 0) {
@@ -355,7 +355,7 @@ static __init bool randomized_test(void)
                                mutated[k] = (mutated[k] & mutate_mask[k]) |
                                             (~mutate_mask[k] &
                                              get_random_u8());
-                       cidr = get_random_u32_below(128) + 1;
+                       cidr = get_random_u32_inclusive(1, 128);
                        peer = peers[get_random_u32_below(NUM_PEERS)];
                        if (wg_allowedips_insert_v6(&t,
                                                    (struct in6_addr *)mutated,

diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
index 23c971b7796538def25593ff90ff62c1ed0cc107..c704ca75213896cfd597db4fb380b52ed04d7e9f 100644 (file)
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
@@ -1128,7 +1128,7 @@ static void brcmf_p2p_afx_handler(struct work_struct *work)
        if (afx_hdl->is_listen && afx_hdl->my_listen_chan)
                /* 100ms ~ 300ms */
                err = brcmf_p2p_discover_listen(p2p, afx_hdl->my_listen_chan,
-                                               100 * (1 + get_random_u32_below(3)));
+                                               100 * get_random_u32_inclusive(1, 3));
        else
                err = brcmf_p2p_act_frm_search(p2p, afx_hdl->peer_listen_chan);
 

diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
index 1696fbf1009a5dfd94f4655340ec6d418340bc10..3a7a44bb3c60308036afaf84b2cfc0e3c0c81425 100644 (file)
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
@@ -1099,7 +1099,7 @@ static void iwl_mvm_mac_ctxt_cmd_fill_ap(struct iwl_mvm *mvm,
                        iwl_mvm_mac_ap_iterator, &data);
 
                if (data.beacon_device_ts) {
-                       u32 rand = get_random_u32_below(64 - 36) + 36;
+                       u32 rand = get_random_u32_inclusive(36, 63);
                        mvmvif->ap_beacon_time = data.beacon_device_ts +
                                ieee80211_tu_to_usec(data.beacon_int * rand /
                                                     100);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 334415d946f8794979b3e7ea4bccb3a15d46407b..b304692c0cf5014ef02073eaaf1abd725e4074a7 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -2588,7 +2588,7 @@ static void new_curseg(struct f2fs_sb_info *sbi, int type, bool new_sec)
        curseg->alloc_type = LFS;
        if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_BLK)
                curseg->fragment_remained_chunk =
-                               get_random_u32_below(sbi->max_fragment_chunk) + 1;
+                               get_random_u32_inclusive(1, sbi->max_fragment_chunk);
 }
 
 static int __next_free_blkoff(struct f2fs_sb_info *sbi,
@@ -2625,9 +2625,9 @@ static void __refresh_next_blkoff(struct f2fs_sb_info *sbi,
                        /* To allocate block chunks in different sizes, use random number */
                        if (--seg->fragment_remained_chunk <= 0) {
                                seg->fragment_remained_chunk =
-                                  get_random_u32_below(sbi->max_fragment_chunk) + 1;
+                                  get_random_u32_inclusive(1, sbi->max_fragment_chunk);
                                seg->next_blkoff +=
-                                  get_random_u32_below(sbi->max_fragment_hole) + 1;
+                                  get_random_u32_inclusive(1, sbi->max_fragment_hole);
                        }
                }
        }

diff --git a/kernel/kcsan/selftest.c b/kernel/kcsan/selftest.c
index 7b619f16a492ce5bdc6d523cce1367e79eecba1e..8679322450f22a548fec30f09b01db8c17cde224 100644 (file)
--- a/kernel/kcsan/selftest.c
+++ b/kernel/kcsan/selftest.c
@@ -31,7 +31,7 @@ static bool __init test_encode_decode(void)
        int i;
 
        for (i = 0; i < ITERS_PER_TEST; ++i) {
-               size_t size = get_random_u32_below(MAX_ENCODABLE_SIZE) + 1;
+               size_t size = get_random_u32_inclusive(1, MAX_ENCODABLE_SIZE);
                bool is_write = !!get_random_u32_below(2);
                unsigned long verif_masked_addr;
                long encoded_watchpoint;

diff --git a/lib/test_hexdump.c b/lib/test_hexdump.c
index efc50fd30a4443b3e6454a5eef6ef35867f67a62..b916801f23a896056512002d15317931f5bd38a2 100644 (file)
--- a/lib/test_hexdump.c
+++ b/lib/test_hexdump.c
@@ -149,7 +149,7 @@ static void __init test_hexdump(size_t len, int rowsize, int groupsize,
 static void __init test_hexdump_set(int rowsize, bool ascii)
 {
        size_t d = min_t(size_t, sizeof(data_b), rowsize);
-       size_t len = get_random_u32_below(d) + 1;
+       size_t len = get_random_u32_inclusive(1, d);
 
        test_hexdump(len, rowsize, 4, ascii);
        test_hexdump(len, rowsize, 2, ascii);
@@ -208,7 +208,7 @@ static void __init test_hexdump_overflow(size_t buflen, size_t len,
 static void __init test_hexdump_overflow_set(size_t buflen, bool ascii)
 {
        unsigned int i = 0;
-       int rs = (get_random_u32_below(2) + 1) * 16;
+       int rs = get_random_u32_inclusive(1, 2) * 16;
 
        do {
                int gs = 1 << i;
@@ -223,11 +223,11 @@ static int __init test_hexdump_init(void)
        unsigned int i;
        int rowsize;
 
-       rowsize = (get_random_u32_below(2) + 1) * 16;
+       rowsize = get_random_u32_inclusive(1, 2) * 16;
        for (i = 0; i < 16; i++)
                test_hexdump_set(rowsize, false);
 
-       rowsize = (get_random_u32_below(2) + 1) * 16;
+       rowsize = get_random_u32_inclusive(1, 2) * 16;
        for (i = 0; i < 16; i++)
                test_hexdump_set(rowsize, true);
 

diff --git a/lib/test_printf.c b/lib/test_printf.c
index 6d10187eddaceae405ed56f9dcf35e87fe4d186a..f098914a48d55cba248292d121280128940448b7 100644 (file)
--- a/lib/test_printf.c
+++ b/lib/test_printf.c
@@ -126,7 +126,7 @@ __test(const char *expect, int elen, const char *fmt, ...)
         * be able to print it as expected.
         */
        failed_tests += do_test(BUF_SIZE, expect, elen, fmt, ap);
-       rand = 1 + get_random_u32_below(elen + 1);
+       rand = get_random_u32_inclusive(1, elen + 1);
        /* Since elen < BUF_SIZE, we have 1 <= rand <= BUF_SIZE. */
        failed_tests += do_test(rand, expect, elen, fmt, ap);
        failed_tests += do_test(0, expect, elen, fmt, ap);

diff --git a/lib/test_vmalloc.c b/lib/test_vmalloc.c
index 104f09ea5fcc6ab8e421b46529808a02b6139e45..f90d2c27675b6340af04506660378002d0bcd273 100644 (file)
--- a/lib/test_vmalloc.c
+++ b/lib/test_vmalloc.c
@@ -151,7 +151,7 @@ static int random_size_alloc_test(void)
        int i;
 
        for (i = 0; i < test_loop_count; i++) {
-               n = get_random_u32_below(100) + 1;
+               n = get_random_u32_inclusive(1, 100);
                p = vmalloc(n * PAGE_SIZE);
 
                if (!p)
@@ -291,12 +291,12 @@ pcpu_alloc_test(void)
                return -1;
 
        for (i = 0; i < 35000; i++) {
-               size = get_random_u32_below(PAGE_SIZE / 4) + 1;
+               size = get_random_u32_inclusive(1, PAGE_SIZE / 4);
 
                /*
                 * Maximum PAGE_SIZE
                 */
-               align = 1 << (get_random_u32_below(11) + 1);
+               align = 1 << get_random_u32_inclusive(1, 11);
 
                pcpu[i] = __alloc_percpu(size, align);
                if (!pcpu[i])

diff --git a/mm/kasan/kasan_test.c b/mm/kasan/kasan_test.c
index 640f9c7f8e44e2ef6826ac7c9ca708b72cad8441..54181eba3e2420703e70a4d6a765690525565934 100644 (file)
--- a/mm/kasan/kasan_test.c
+++ b/mm/kasan/kasan_test.c
@@ -1299,7 +1299,7 @@ static void match_all_not_assigned(struct kunit *test)
        KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
 
        for (i = 0; i < 256; i++) {
-               size = get_random_u32_below(1024) + 1;
+               size = get_random_u32_inclusive(1, 1024);
                ptr = kmalloc(size, GFP_KERNEL);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
                KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
@@ -1308,7 +1308,7 @@ static void match_all_not_assigned(struct kunit *test)
        }
 
        for (i = 0; i < 256; i++) {
-               order = get_random_u32_below(4) + 1;
+               order = get_random_u32_inclusive(1, 4);
                pages = alloc_pages(GFP_KERNEL, order);
                ptr = page_address(pages);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
@@ -1321,7 +1321,7 @@ static void match_all_not_assigned(struct kunit *test)
                return;
 
        for (i = 0; i < 256; i++) {
-               size = get_random_u32_below(1024) + 1;
+               size = get_random_u32_inclusive(1, 1024);
                ptr = vmalloc(size);
                KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
                KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);

diff --git a/mm/kfence/kfence_test.c b/mm/kfence/kfence_test.c
index 20028c1797963dc11f63c2d4f9e62b47002f42be..b5d66a69200d16bb55b887ef6edb64bb9d0a68e7 100644 (file)
--- a/mm/kfence/kfence_test.c
+++ b/mm/kfence/kfence_test.c
@@ -532,7 +532,7 @@ static void test_free_bulk(struct kunit *test)
        int iter;
 
        for (iter = 0; iter < 5; iter++) {
-               const size_t size = setup_test_cache(test, 8 + get_random_u32_below(300),
+               const size_t size = setup_test_cache(test, get_random_u32_inclusive(8, 307),
                                                     0, (iter & 1) ? ctor_set_x : NULL);
                void *objects[] = {
                        test_alloc(test, size, GFP_KERNEL, ALLOCATE_RIGHT),

diff --git a/mm/swapfile.c b/mm/swapfile.c
index e9318305a24a5aa97b390ecc00897ed800f695a0..4ee31056d3f876a139fb9081eecfa1bcb4d45385 100644 (file)
--- a/mm/swapfile.c
+++ b/mm/swapfile.c
@@ -772,8 +772,7 @@ static void set_cluster_next(struct swap_info_struct *si, unsigned long next)
                /* No free swap slots available */
                if (si->highest_bit <= si->lowest_bit)
                        return;
-               next = si->lowest_bit +
-                       get_random_u32_below(si->highest_bit - si->lowest_bit + 1);
+               next = get_random_u32_inclusive(si->lowest_bit, si->highest_bit);
                next = ALIGN_DOWN(next, SWAP_ADDRESS_SPACE_PAGES);
                next = max_t(unsigned int, next, si->lowest_bit);
        }
@@ -3089,7 +3088,7 @@ SYSCALL_DEFINE2(swapon, const char __user *, specialfile, int, swap_flags)
                 */
                for_each_possible_cpu(cpu) {
                        per_cpu(*p->cluster_next_cpu, cpu) =
-                               1 + get_random_u32_below(p->highest_bit);
+                               get_random_u32_inclusive(1, p->highest_bit);
                }
                nr_cluster = DIV_ROUND_UP(maxpages, SWAPFILE_CLUSTER);
 

diff --git a/net/bluetooth/mgmt.c b/net/bluetooth/mgmt.c
index b2f9679066c4a477b05b5d8cb3601b0ed259f999..81ce668b0b77de01204e4f62045c0cf73fd66190 100644 (file)
--- a/net/bluetooth/mgmt.c
+++ b/net/bluetooth/mgmt.c
@@ -7373,9 +7373,8 @@ static int get_conn_info(struct sock *sk, struct hci_dev *hdev, void *data,
        /* To avoid client trying to guess when to poll again for information we
         * calculate conn info age as random value between min/max set in hdev.
         */
-       conn_info_age = hdev->conn_info_min_age +
-                       get_random_u32_below(hdev->conn_info_max_age -
-                                            hdev->conn_info_min_age);
+       conn_info_age = get_random_u32_inclusive(hdev->conn_info_min_age,
+                                                hdev->conn_info_max_age - 1);
 
        /* Query controller to refresh cached values if they are too old or were
         * never read.

diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index 95da2ddc1c20b65079603090f6590de852da57c4..760238196db14de0f764f11b66cc3e79d885b14f 100644 (file)
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -2380,9 +2380,8 @@ static void set_cur_queue_map(struct pktgen_dev *pkt_dev)
        else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
                __u16 t;
                if (pkt_dev->flags & F_QUEUE_MAP_RND) {
-                       t = get_random_u32_below(pkt_dev->queue_map_max -
-                                                pkt_dev->queue_map_min + 1) +
-                           pkt_dev->queue_map_min;
+                       t = get_random_u32_inclusive(pkt_dev->queue_map_min,
+                                                    pkt_dev->queue_map_max);
                } else {
                        t = pkt_dev->cur_queue_map + 1;
                        if (t > pkt_dev->queue_map_max)
@@ -2478,9 +2477,8 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
 
        if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
                if (pkt_dev->flags & F_UDPSRC_RND)
-                       pkt_dev->cur_udp_src = get_random_u32_below(
-                               pkt_dev->udp_src_max - pkt_dev->udp_src_min) +
-                               pkt_dev->udp_src_min;
+                       pkt_dev->cur_udp_src = get_random_u32_inclusive(pkt_dev->udp_src_min,
+                                                                       pkt_dev->udp_src_max - 1);
 
                else {
                        pkt_dev->cur_udp_src++;
@@ -2491,9 +2489,8 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
 
        if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
                if (pkt_dev->flags & F_UDPDST_RND) {
-                       pkt_dev->cur_udp_dst = get_random_u32_below(
-                               pkt_dev->udp_dst_max - pkt_dev->udp_dst_min) +
-                               pkt_dev->udp_dst_min;
+                       pkt_dev->cur_udp_dst = get_random_u32_inclusive(pkt_dev->udp_dst_min,
+                                                                       pkt_dev->udp_dst_max - 1);
                } else {
                        pkt_dev->cur_udp_dst++;
                        if (pkt_dev->cur_udp_dst >= pkt_dev->udp_dst_max)
@@ -2508,7 +2505,7 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
                if (imn < imx) {
                        __u32 t;
                        if (pkt_dev->flags & F_IPSRC_RND)
-                               t = get_random_u32_below(imx - imn) + imn;
+                               t = get_random_u32_inclusive(imn, imx - 1);
                        else {
                                t = ntohl(pkt_dev->cur_saddr);
                                t++;
@@ -2530,8 +2527,7 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
                                if (pkt_dev->flags & F_IPDST_RND) {
 
                                        do {
-                                               t = get_random_u32_below(imx - imn) +
-                                                   imn;
+                                               t = get_random_u32_inclusive(imn, imx - 1);
                                                s = htonl(t);
                                        } while (ipv4_is_loopback(s) ||
                                                ipv4_is_multicast(s) ||
@@ -2578,9 +2574,8 @@ static void mod_cur_headers(struct pktgen_dev *pkt_dev)
        if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
                __u32 t;
                if (pkt_dev->flags & F_TXSIZE_RND) {
-                       t = get_random_u32_below(pkt_dev->max_pkt_size -
-                                                pkt_dev->min_pkt_size) +
-                           pkt_dev->min_pkt_size;
+                       t = get_random_u32_inclusive(pkt_dev->min_pkt_size,
+                                                    pkt_dev->max_pkt_size - 1);
                } else {
                        t = pkt_dev->cur_pkt_size + 1;
                        if (t > pkt_dev->max_pkt_size)

diff --git a/net/ipv4/tcp_input.c b/net/ipv4/tcp_input.c
index 3b076e5ba932dd5536391ba34db886d999e98114..23cf418efe4ff56be2be176fde547af8b800c467 100644 (file)
--- a/net/ipv4/tcp_input.c
+++ b/net/ipv4/tcp_input.c
@@ -3647,7 +3647,7 @@ static void tcp_send_challenge_ack(struct sock *sk)
 
                WRITE_ONCE(net->ipv4.tcp_challenge_timestamp, now);
                WRITE_ONCE(net->ipv4.tcp_challenge_count,
-                          half + get_random_u32_below(ack_limit));
+                          get_random_u32_inclusive(half, ack_limit + half - 1));
        }
        count = READ_ONCE(net->ipv4.tcp_challenge_count);
        if (count > 0) {

diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c
index daf89a2eb492a367705d89cca66fabdf8cd9c991..d720f6f5de3fe2780a81410edf21da0be454dfa8 100644 (file)
--- a/net/ipv6/addrconf.c
+++ b/net/ipv6/addrconf.c
@@ -104,7 +104,7 @@ static inline u32 cstamp_delta(unsigned long cstamp)
 static inline s32 rfc3315_s14_backoff_init(s32 irt)
 {
        /* multiply 'initial retransmission time' by 0.9 .. 1.1 */
-       u64 tmp = (900000 + get_random_u32_below(200001)) * (u64)irt;
+       u64 tmp = get_random_u32_inclusive(900000, 1100000) * (u64)irt;
        do_div(tmp, 1000000);
        return (s32)tmp;
 }
@@ -112,11 +112,11 @@ static inline s32 rfc3315_s14_backoff_init(s32 irt)
 static inline s32 rfc3315_s14_backoff_update(s32 rt, s32 mrt)
 {
        /* multiply 'retransmission timeout' by 1.9 .. 2.1 */
-       u64 tmp = (1900000 + get_random_u32_below(200001)) * (u64)rt;
+       u64 tmp = get_random_u32_inclusive(1900000, 2100000) * (u64)rt;
        do_div(tmp, 1000000);
        if ((s32)tmp > mrt) {
                /* multiply 'maximum retransmission time' by 0.9 .. 1.1 */
-               tmp = (900000 + get_random_u32_below(200001)) * (u64)mrt;
+               tmp = get_random_u32_inclusive(900000, 1100000) * (u64)mrt;
                do_div(tmp, 1000000);
        }
        return (s32)tmp;

diff --git a/net/xfrm/xfrm_state.c b/net/xfrm/xfrm_state.c
index 40f831854774db30646d1369433f9d8d488b3e2f..d63a3644ee1afe6adfb4112f3ef4340fce940318 100644 (file)
--- a/net/xfrm/xfrm_state.c
+++ b/net/xfrm/xfrm_state.c
@@ -2072,7 +2072,7 @@ int xfrm_alloc_spi(struct xfrm_state *x, u32 low, u32 high)
        } else {
                u32 spi = 0;
                for (h = 0; h < high-low+1; h++) {
-                       spi = low + get_random_u32_below(high - low + 1);
+                       spi = get_random_u32_inclusive(low, high);
                        x0 = xfrm_state_lookup(net, mark, &x->id.daddr, htonl(spi), x->id.proto, x->props.family);
                        if (x0 == NULL) {
                                newspi = htonl(spi);