Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
treewide: use get_random_u32_below() instead of deprecated function
This is a simple mechanical transformation done by:
@@
expression E;
@@
- prandom_u32_max
+ get_random_u32_below
(E)
Reviewed-by: Kees Cook <keescook@chromium.org>
Reviewed-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Acked-by: Darrick J. Wong <djwong@kernel.org> # for xfs
Reviewed-by: SeongJae Park <sj@kernel.org> # for damon
Reviewed-by: Jason Gunthorpe <jgg@nvidia.com> # for infiniband
Reviewed-by: Russell King (Oracle) <rmk+kernel@armlinux.org.uk> # for arm
Acked-by: Ulf Hansson <ulf.hansson@linaro.org> # for mmc
Signed-off-by: Jason A. Donenfeld <Jason@zx2c4.com>
+280
-280
+1
-1
arch/arm/kernel/process.c
+1
-1
arch/arm/kernel/process.c
+1
-1
arch/arm64/kernel/process.c
+1
-1
arch/arm64/kernel/process.c
+1
-1
arch/loongarch/kernel/process.c
+1
-1
arch/loongarch/kernel/process.c
+1
-1
arch/loongarch/kernel/vdso.c
+1
-1
arch/loongarch/kernel/vdso.c
+1
-1
arch/mips/kernel/process.c
+1
-1
arch/mips/kernel/process.c
+1
-1
arch/mips/kernel/vdso.c
+1
-1
arch/mips/kernel/vdso.c
+1
-1
arch/parisc/kernel/vdso.c
+1
-1
arch/parisc/kernel/vdso.c
+2
-2
arch/powerpc/crypto/crc-vpmsum_test.c
+2
-2
arch/powerpc/crypto/crc-vpmsum_test.c
···
77
77
78
78
pr_info("crc-vpmsum_test begins, %lu iterations\n", iterations);
79
79
for (i=0; i<iterations; i++) {
80
-
size_t offset = prandom_u32_max(16);
81
-
size_t len = prandom_u32_max(MAX_CRC_LENGTH);
80
+
size_t offset = get_random_u32_below(16);
81
+
size_t len = get_random_u32_below(MAX_CRC_LENGTH);
82
82
83
83
if (len <= offset)
84
84
continue;
+1
-1
arch/powerpc/kernel/process.c
+1
-1
arch/powerpc/kernel/process.c
+1
-1
arch/s390/kernel/process.c
+1
-1
arch/s390/kernel/process.c
+1
-1
arch/s390/kernel/vdso.c
+1
-1
arch/s390/kernel/vdso.c
+1
-1
arch/sparc/vdso/vma.c
+1
-1
arch/sparc/vdso/vma.c
+1
-1
arch/um/kernel/process.c
+1
-1
arch/um/kernel/process.c
+1
-1
arch/x86/entry/vdso/vma.c
+1
-1
arch/x86/entry/vdso/vma.c
+1
-1
arch/x86/kernel/module.c
+1
-1
arch/x86/kernel/module.c
+1
-1
arch/x86/kernel/process.c
+1
-1
arch/x86/kernel/process.c
+2
-2
arch/x86/mm/pat/cpa-test.c
+2
-2
arch/x86/mm/pat/cpa-test.c
···
136
136
failed += print_split(&sa);
137
137
138
138
for (i = 0; i < NTEST; i++) {
139
-
unsigned long pfn = prandom_u32_max(max_pfn_mapped);
139
+
unsigned long pfn = get_random_u32_below(max_pfn_mapped);
140
140
141
141
addr[i] = (unsigned long)__va(pfn << PAGE_SHIFT);
142
-
len[i] = prandom_u32_max(NPAGES);
142
+
len[i] = get_random_u32_below(NPAGES);
143
143
len[i] = min_t(unsigned long, len[i], max_pfn_mapped - pfn - 1);
144
144
145
145
if (len[i] == 0)
+1
-1
crypto/rsa-pkcs1pad.c
+1
-1
crypto/rsa-pkcs1pad.c
···
253
253
ps_end = ctx->key_size - req->src_len - 2;
254
254
req_ctx->in_buf[0] = 0x02;
255
255
for (i = 1; i < ps_end; i++)
256
-
req_ctx->in_buf[i] = 1 + prandom_u32_max(255);
256
+
req_ctx->in_buf[i] = 1 + get_random_u32_below(255);
257
257
req_ctx->in_buf[ps_end] = 0x00;
258
258
259
259
pkcs1pad_sg_set_buf(req_ctx->in_sg, req_ctx->in_buf,
+43
-43
crypto/testmgr.c
+43
-43
crypto/testmgr.c
···
855
855
/* Generate a random length in range [0, max_len], but prefer smaller values */
856
856
static unsigned int generate_random_length(unsigned int max_len)
857
857
{
858
-
unsigned int len = prandom_u32_max(max_len + 1);
858
+
unsigned int len = get_random_u32_below(max_len + 1);
859
859
860
-
switch (prandom_u32_max(4)) {
860
+
switch (get_random_u32_below(4)) {
861
861
case 0:
862
862
return len % 64;
863
863
case 1:
···
874
874
{
875
875
size_t bitpos;
876
876
877
-
bitpos = prandom_u32_max(size * 8);
877
+
bitpos = get_random_u32_below(size * 8);
878
878
buf[bitpos / 8] ^= 1 << (bitpos % 8);
879
879
}
880
880
881
881
/* Flip a random byte in the given nonempty data buffer */
882
882
static void flip_random_byte(u8 *buf, size_t size)
883
883
{
884
-
buf[prandom_u32_max(size)] ^= 0xff;
884
+
buf[get_random_u32_below(size)] ^= 0xff;
885
885
}
886
886
887
887
/* Sometimes make some random changes to the given nonempty data buffer */
···
891
891
size_t i;
892
892
893
893
/* Sometimes flip some bits */
894
-
if (prandom_u32_max(4) == 0) {
895
-
num_flips = min_t(size_t, 1 << prandom_u32_max(8), size * 8);
894
+
if (get_random_u32_below(4) == 0) {
895
+
num_flips = min_t(size_t, 1 << get_random_u32_below(8), size * 8);
896
896
for (i = 0; i < num_flips; i++)
897
897
flip_random_bit(buf, size);
898
898
}
899
899
900
900
/* Sometimes flip some bytes */
901
-
if (prandom_u32_max(4) == 0) {
902
-
num_flips = min_t(size_t, 1 << prandom_u32_max(8), size);
901
+
if (get_random_u32_below(4) == 0) {
902
+
num_flips = min_t(size_t, 1 << get_random_u32_below(8), size);
903
903
for (i = 0; i < num_flips; i++)
904
904
flip_random_byte(buf, size);
905
905
}
···
915
915
if (count == 0)
916
916
return;
917
917
918
-
switch (prandom_u32_max(8)) { /* Choose a generation strategy */
918
+
switch (get_random_u32_below(8)) { /* Choose a generation strategy */
919
919
case 0:
920
920
case 1:
921
921
/* All the same byte, plus optional mutations */
922
-
switch (prandom_u32_max(4)) {
922
+
switch (get_random_u32_below(4)) {
923
923
case 0:
924
924
b = 0x00;
925
925
break;
···
959
959
unsigned int this_len;
960
960
const char *flushtype_str;
961
961
962
-
if (div == &divs[max_divs - 1] || prandom_u32_max(2) == 0)
962
+
if (div == &divs[max_divs - 1] || get_random_u32_below(2) == 0)
963
963
this_len = remaining;
964
964
else
965
-
this_len = 1 + prandom_u32_max(remaining);
965
+
this_len = 1 + get_random_u32_below(remaining);
966
966
div->proportion_of_total = this_len;
967
967
968
-
if (prandom_u32_max(4) == 0)
969
-
div->offset = (PAGE_SIZE - 128) + prandom_u32_max(128);
970
-
else if (prandom_u32_max(2) == 0)
971
-
div->offset = prandom_u32_max(32);
968
+
if (get_random_u32_below(4) == 0)
969
+
div->offset = (PAGE_SIZE - 128) + get_random_u32_below(128);
970
+
else if (get_random_u32_below(2) == 0)
971
+
div->offset = get_random_u32_below(32);
972
972
else
973
-
div->offset = prandom_u32_max(PAGE_SIZE);
974
-
if (prandom_u32_max(8) == 0)
973
+
div->offset = get_random_u32_below(PAGE_SIZE);
974
+
if (get_random_u32_below(8) == 0)
975
975
div->offset_relative_to_alignmask = true;
976
976
977
977
div->flush_type = FLUSH_TYPE_NONE;
978
978
if (gen_flushes) {
979
-
switch (prandom_u32_max(4)) {
979
+
switch (get_random_u32_below(4)) {
980
980
case 0:
981
981
div->flush_type = FLUSH_TYPE_REIMPORT;
982
982
break;
···
988
988
989
989
if (div->flush_type != FLUSH_TYPE_NONE &&
990
990
!(req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) &&
991
-
prandom_u32_max(2) == 0)
991
+
get_random_u32_below(2) == 0)
992
992
div->nosimd = true;
993
993
994
994
switch (div->flush_type) {
···
1035
1035
1036
1036
p += scnprintf(p, end - p, "random:");
1037
1037
1038
-
switch (prandom_u32_max(4)) {
1038
+
switch (get_random_u32_below(4)) {
1039
1039
case 0:
1040
1040
case 1:
1041
1041
cfg->inplace_mode = OUT_OF_PLACE;
···
1050
1050
break;
1051
1051
}
1052
1052
1053
-
if (prandom_u32_max(2) == 0) {
1053
+
if (get_random_u32_below(2) == 0) {
1054
1054
cfg->req_flags |= CRYPTO_TFM_REQ_MAY_SLEEP;
1055
1055
p += scnprintf(p, end - p, " may_sleep");
1056
1056
}
1057
1057
1058
-
switch (prandom_u32_max(4)) {
1058
+
switch (get_random_u32_below(4)) {
1059
1059
case 0:
1060
1060
cfg->finalization_type = FINALIZATION_TYPE_FINAL;
1061
1061
p += scnprintf(p, end - p, " use_final");
···
1071
1071
}
1072
1072
1073
1073
if (!(cfg->req_flags & CRYPTO_TFM_REQ_MAY_SLEEP) &&
1074
-
prandom_u32_max(2) == 0) {
1074
+
get_random_u32_below(2) == 0) {
1075
1075
cfg->nosimd = true;
1076
1076
p += scnprintf(p, end - p, " nosimd");
1077
1077
}
···
1084
1084
cfg->req_flags);
1085
1085
p += scnprintf(p, end - p, "]");
1086
1086
1087
-
if (cfg->inplace_mode == OUT_OF_PLACE && prandom_u32_max(2) == 0) {
1087
+
if (cfg->inplace_mode == OUT_OF_PLACE && get_random_u32_below(2) == 0) {
1088
1088
p += scnprintf(p, end - p, " dst_divs=[");
1089
1089
p = generate_random_sgl_divisions(cfg->dst_divs,
1090
1090
ARRAY_SIZE(cfg->dst_divs),
···
1093
1093
p += scnprintf(p, end - p, "]");
1094
1094
}
1095
1095
1096
-
if (prandom_u32_max(2) == 0) {
1097
-
cfg->iv_offset = 1 + prandom_u32_max(MAX_ALGAPI_ALIGNMASK);
1096
+
if (get_random_u32_below(2) == 0) {
1097
+
cfg->iv_offset = 1 + get_random_u32_below(MAX_ALGAPI_ALIGNMASK);
1098
1098
p += scnprintf(p, end - p, " iv_offset=%u", cfg->iv_offset);
1099
1099
}
1100
1100
1101
-
if (prandom_u32_max(2) == 0) {
1102
-
cfg->key_offset = 1 + prandom_u32_max(MAX_ALGAPI_ALIGNMASK);
1101
+
if (get_random_u32_below(2) == 0) {
1102
+
cfg->key_offset = 1 + get_random_u32_below(MAX_ALGAPI_ALIGNMASK);
1103
1103
p += scnprintf(p, end - p, " key_offset=%u", cfg->key_offset);
1104
1104
}
1105
1105
···
1652
1652
vec->ksize = 0;
1653
1653
if (maxkeysize) {
1654
1654
vec->ksize = maxkeysize;
1655
-
if (prandom_u32_max(4) == 0)
1656
-
vec->ksize = 1 + prandom_u32_max(maxkeysize);
1655
+
if (get_random_u32_below(4) == 0)
1656
+
vec->ksize = 1 + get_random_u32_below(maxkeysize);
1657
1657
generate_random_bytes((u8 *)vec->key, vec->ksize);
1658
1658
1659
1659
vec->setkey_error = crypto_shash_setkey(desc->tfm, vec->key,
···
2218
2218
const unsigned int aad_tail_size = aad_iv ? ivsize : 0;
2219
2219
const unsigned int authsize = vec->clen - vec->plen;
2220
2220
2221
-
if (prandom_u32_max(2) == 0 && vec->alen > aad_tail_size) {
2221
+
if (get_random_u32_below(2) == 0 && vec->alen > aad_tail_size) {
2222
2222
/* Mutate the AAD */
2223
2223
flip_random_bit((u8 *)vec->assoc, vec->alen - aad_tail_size);
2224
-
if (prandom_u32_max(2) == 0)
2224
+
if (get_random_u32_below(2) == 0)
2225
2225
return;
2226
2226
}
2227
-
if (prandom_u32_max(2) == 0) {
2227
+
if (get_random_u32_below(2) == 0) {
2228
2228
/* Mutate auth tag (assuming it's at the end of ciphertext) */
2229
2229
flip_random_bit((u8 *)vec->ctext + vec->plen, authsize);
2230
2230
} else {
···
2249
2249
const unsigned int ivsize = crypto_aead_ivsize(tfm);
2250
2250
const unsigned int authsize = vec->clen - vec->plen;
2251
2251
const bool inauthentic = (authsize >= MIN_COLLISION_FREE_AUTHSIZE) &&
2252
-
(prefer_inauthentic || prandom_u32_max(4) == 0);
2252
+
(prefer_inauthentic || get_random_u32_below(4) == 0);
2253
2253
2254
2254
/* Generate the AAD. */
2255
2255
generate_random_bytes((u8 *)vec->assoc, vec->alen);
···
2257
2257
/* Avoid implementation-defined behavior. */
2258
2258
memcpy((u8 *)vec->assoc + vec->alen - ivsize, vec->iv, ivsize);
2259
2259
2260
-
if (inauthentic && prandom_u32_max(2) == 0) {
2260
+
if (inauthentic && get_random_u32_below(2) == 0) {
2261
2261
/* Generate a random ciphertext. */
2262
2262
generate_random_bytes((u8 *)vec->ctext, vec->clen);
2263
2263
} else {
···
2321
2321
2322
2322
/* Key: length in [0, maxkeysize], but usually choose maxkeysize */
2323
2323
vec->klen = maxkeysize;
2324
-
if (prandom_u32_max(4) == 0)
2325
-
vec->klen = prandom_u32_max(maxkeysize + 1);
2324
+
if (get_random_u32_below(4) == 0)
2325
+
vec->klen = get_random_u32_below(maxkeysize + 1);
2326
2326
generate_random_bytes((u8 *)vec->key, vec->klen);
2327
2327
vec->setkey_error = crypto_aead_setkey(tfm, vec->key, vec->klen);
2328
2328
···
2331
2331
2332
2332
/* Tag length: in [0, maxauthsize], but usually choose maxauthsize */
2333
2333
authsize = maxauthsize;
2334
-
if (prandom_u32_max(4) == 0)
2335
-
authsize = prandom_u32_max(maxauthsize + 1);
2334
+
if (get_random_u32_below(4) == 0)
2335
+
authsize = get_random_u32_below(maxauthsize + 1);
2336
2336
if (prefer_inauthentic && authsize < MIN_COLLISION_FREE_AUTHSIZE)
2337
2337
authsize = MIN_COLLISION_FREE_AUTHSIZE;
2338
2338
if (WARN_ON(authsize > maxdatasize))
···
2342
2342
2343
2343
/* AAD, plaintext, and ciphertext lengths */
2344
2344
total_len = generate_random_length(maxdatasize);
2345
-
if (prandom_u32_max(4) == 0)
2345
+
if (get_random_u32_below(4) == 0)
2346
2346
vec->alen = 0;
2347
2347
else
2348
2348
vec->alen = generate_random_length(total_len);
···
2958
2958
2959
2959
/* Key: length in [0, maxkeysize], but usually choose maxkeysize */
2960
2960
vec->klen = maxkeysize;
2961
-
if (prandom_u32_max(4) == 0)
2962
-
vec->klen = prandom_u32_max(maxkeysize + 1);
2961
+
if (get_random_u32_below(4) == 0)
2962
+
vec->klen = get_random_u32_below(maxkeysize + 1);
2963
2963
generate_random_bytes((u8 *)vec->key, vec->klen);
2964
2964
vec->setkey_error = crypto_skcipher_setkey(tfm, vec->key, vec->klen);
2965
2965
+2
-2
drivers/block/drbd/drbd_receiver.c
+2
-2
drivers/block/drbd/drbd_receiver.c
···
781
781
782
782
timeo = connect_int * HZ;
783
783
/* 28.5% random jitter */
784
-
timeo += prandom_u32_max(2) ? timeo / 7 : -timeo / 7;
784
+
timeo += get_random_u32_below(2) ? timeo / 7 : -timeo / 7;
785
785
786
786
err = wait_for_completion_interruptible_timeout(&ad->door_bell, timeo);
787
787
if (err <= 0)
···
1004
1004
drbd_warn(connection, "Error receiving initial packet\n");
1005
1005
sock_release(s);
1006
1006
randomize:
1007
-
if (prandom_u32_max(2))
1007
+
if (get_random_u32_below(2))
1008
1008
goto retry;
1009
1009
}
1010
1010
}
+1
-1
drivers/bus/mhi/host/internal.h
+1
-1
drivers/bus/mhi/host/internal.h
···
129
129
#define PRIMARY_CMD_RING 0
130
130
#define MHI_DEV_WAKE_DB 127
131
131
#define MHI_MAX_MTU 0xffff
132
-
#define MHI_RANDOM_U32_NONZERO(bmsk) (prandom_u32_max(bmsk) + 1)
132
+
#define MHI_RANDOM_U32_NONZERO(bmsk) (get_random_u32_below(bmsk) + 1)
133
133
134
134
enum mhi_er_type {
135
135
MHI_ER_TYPE_INVALID = 0x0,
+3
-3
drivers/dma-buf/st-dma-fence-chain.c
+3
-3
drivers/dma-buf/st-dma-fence-chain.c
···
400
400
struct dma_fence *fence = dma_fence_get(data->fc.tail);
401
401
int seqno;
402
402
403
-
seqno = prandom_u32_max(data->fc.chain_length) + 1;
403
+
seqno = get_random_u32_below(data->fc.chain_length) + 1;
404
404
405
405
err = dma_fence_chain_find_seqno(&fence, seqno);
406
406
if (err) {
···
429
429
dma_fence_put(fence);
430
430
431
431
signal:
432
-
seqno = prandom_u32_max(data->fc.chain_length - 1);
432
+
seqno = get_random_u32_below(data->fc.chain_length - 1);
433
433
dma_fence_signal(data->fc.fences[seqno]);
434
434
cond_resched();
435
435
}
···
637
637
while (--count) {
638
638
unsigned int swp;
639
639
640
-
swp = prandom_u32_max(count + 1);
640
+
swp = get_random_u32_below(count + 1);
641
641
if (swp == count)
642
642
continue;
643
643
+1
-1
drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c
+1
-1
drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c
···
2424
2424
/* Check whether the file_priv has already selected one ring. */
2425
2425
if ((int)file_priv->bsd_engine < 0)
2426
2426
file_priv->bsd_engine =
2427
-
prandom_u32_max(num_vcs_engines(dev_priv));
2427
+
get_random_u32_below(num_vcs_engines(dev_priv));
2428
2428
2429
2429
return file_priv->bsd_engine;
2430
2430
}
+1
-1
drivers/gpu/drm/i915/gt/intel_execlists_submission.c
+1
-1
drivers/gpu/drm/i915/gt/intel_execlists_submission.c
···
3689
3689
* NB This does not force us to execute on this engine, it will just
3690
3690
* typically be the first we inspect for submission.
3691
3691
*/
3692
-
swp = prandom_u32_max(ve->num_siblings);
3692
+
swp = get_random_u32_below(ve->num_siblings);
3693
3693
if (swp)
3694
3694
swap(ve->siblings[swp], ve->siblings[0]);
3695
3695
}
+2
-2
drivers/gpu/drm/i915/intel_memory_region.c
+2
-2
drivers/gpu/drm/i915/intel_memory_region.c
···
38
38
u8 value, resource_size_t offset,
39
39
const void *caller)
40
40
{
41
-
int byte = prandom_u32_max(pagesize);
41
+
int byte = get_random_u32_below(pagesize);
42
42
u8 result[3];
43
43
44
44
memset_io(va, value, pagesize); /* or GPF! */
···
92
92
static resource_size_t random_page(resource_size_t last)
93
93
{
94
94
/* Limited to low 44b (16TiB), but should suffice for a spot check */
95
-
return prandom_u32_max(last >> PAGE_SHIFT) << PAGE_SHIFT;
95
+
return get_random_u32_below(last >> PAGE_SHIFT) << PAGE_SHIFT;
96
96
}
97
97
98
98
static int iomemtest(struct intel_memory_region *mem,
+1
-1
drivers/infiniband/core/cma.c
+1
-1
drivers/infiniband/core/cma.c
···
3807
3807
3808
3808
inet_get_local_port_range(net, &low, &high);
3809
3809
remaining = (high - low) + 1;
3810
-
rover = prandom_u32_max(remaining) + low;
3810
+
rover = get_random_u32_below(remaining) + low;
3811
3811
retry:
3812
3812
if (last_used_port != rover) {
3813
3813
struct rdma_bind_list *bind_list;
+2
-2
drivers/infiniband/hw/cxgb4/id_table.c
+2
-2
drivers/infiniband/hw/cxgb4/id_table.c
···
54
54
55
55
if (obj < alloc->max) {
56
56
if (alloc->flags & C4IW_ID_TABLE_F_RANDOM)
57
-
alloc->last += prandom_u32_max(RANDOM_SKIP);
57
+
alloc->last += get_random_u32_below(RANDOM_SKIP);
58
58
else
59
59
alloc->last = obj + 1;
60
60
if (alloc->last >= alloc->max)
···
85
85
alloc->start = start;
86
86
alloc->flags = flags;
87
87
if (flags & C4IW_ID_TABLE_F_RANDOM)
88
-
alloc->last = prandom_u32_max(RANDOM_SKIP);
88
+
alloc->last = get_random_u32_below(RANDOM_SKIP);
89
89
else
90
90
alloc->last = 0;
91
91
alloc->max = num;
+2
-2
drivers/infiniband/hw/hns/hns_roce_ah.c
+2
-2
drivers/infiniband/hw/hns/hns_roce_ah.c
···
41
41
u16 sport;
42
42
43
43
if (!fl)
44
-
sport = prandom_u32_max(IB_ROCE_UDP_ENCAP_VALID_PORT_MAX + 1 -
45
-
IB_ROCE_UDP_ENCAP_VALID_PORT_MIN) +
44
+
sport = get_random_u32_below(IB_ROCE_UDP_ENCAP_VALID_PORT_MAX +
45
+
1 - IB_ROCE_UDP_ENCAP_VALID_PORT_MIN) +
46
46
IB_ROCE_UDP_ENCAP_VALID_PORT_MIN;
47
47
else
48
48
sport = rdma_flow_label_to_udp_sport(fl);
+1
-1
drivers/infiniband/ulp/rtrs/rtrs-clt.c
+1
-1
drivers/infiniband/ulp/rtrs/rtrs-clt.c
···
1517
1517
rtrs_clt_stop_and_destroy_conns(clt_path);
1518
1518
queue_delayed_work(rtrs_wq, &clt_path->reconnect_dwork,
1519
1519
msecs_to_jiffies(delay_ms +
1520
-
prandom_u32_max(RTRS_RECONNECT_SEED)));
1520
+
get_random_u32_below(RTRS_RECONNECT_SEED)));
1521
1521
}
1522
1522
1523
1523
static struct rtrs_clt_path *alloc_path(struct rtrs_clt_sess *clt,
+1
-1
drivers/md/bcache/request.c
+1
-1
drivers/md/bcache/request.c
+4
-4
drivers/media/common/v4l2-tpg/v4l2-tpg-core.c
+4
-4
drivers/media/common/v4l2-tpg/v4l2-tpg-core.c
···
872
872
} else if (tpg->pattern == TPG_PAT_NOISE) {
873
873
r = g = b = get_random_u8();
874
874
} else if (k == TPG_COLOR_RANDOM) {
875
-
r = g = b = tpg->qual_offset + prandom_u32_max(196);
875
+
r = g = b = tpg->qual_offset + get_random_u32_below(196);
876
876
} else if (k >= TPG_COLOR_RAMP) {
877
877
r = g = b = k - TPG_COLOR_RAMP;
878
878
}
···
2286
2286
params->wss_width = tpg->crop.width;
2287
2287
params->wss_width = tpg_hscale_div(tpg, p, params->wss_width);
2288
2288
params->wss_random_offset =
2289
-
params->twopixsize * prandom_u32_max(tpg->src_width / 2);
2289
+
params->twopixsize * get_random_u32_below(tpg->src_width / 2);
2290
2290
2291
2291
if (tpg->crop.left < tpg->border.left) {
2292
2292
left_pillar_width = tpg->border.left - tpg->crop.left;
···
2495
2495
linestart_newer = tpg->black_line[p];
2496
2496
} else if (tpg->pattern == TPG_PAT_NOISE || tpg->qual == TPG_QUAL_NOISE) {
2497
2497
linestart_older = tpg->random_line[p] +
2498
-
twopixsize * prandom_u32_max(tpg->src_width / 2);
2498
+
twopixsize * get_random_u32_below(tpg->src_width / 2);
2499
2499
linestart_newer = tpg->random_line[p] +
2500
-
twopixsize * prandom_u32_max(tpg->src_width / 2);
2500
+
twopixsize * get_random_u32_below(tpg->src_width / 2);
2501
2501
} else {
2502
2502
unsigned frame_line_old =
2503
2503
(frame_line + mv_vert_old) % tpg->src_height;
+4
-4
drivers/media/test-drivers/vidtv/vidtv_demod.c
+4
-4
drivers/media/test-drivers/vidtv/vidtv_demod.c
···
188
188
* Also, usually, signal strength is a negative number in dBm.
189
189
*/
190
190
c->strength.stat[0].svalue = state->tuner_cnr;
191
-
c->strength.stat[0].svalue -= prandom_u32_max(state->tuner_cnr / 50);
191
+
c->strength.stat[0].svalue -= get_random_u32_below(state->tuner_cnr / 50);
192
192
c->strength.stat[0].svalue -= 68000; /* Adjust to a better range */
193
193
194
194
c->cnr.stat[0].svalue = state->tuner_cnr;
195
-
c->cnr.stat[0].svalue -= prandom_u32_max(state->tuner_cnr / 50);
195
+
c->cnr.stat[0].svalue -= get_random_u32_below(state->tuner_cnr / 50);
196
196
}
197
197
198
198
static int vidtv_demod_read_status(struct dvb_frontend *fe,
···
213
213
214
214
if (snr < cnr2qual->cnr_ok) {
215
215
/* eventually lose the TS lock */
216
-
if (prandom_u32_max(100) < config->drop_tslock_prob_on_low_snr)
216
+
if (get_random_u32_below(100) < config->drop_tslock_prob_on_low_snr)
217
217
state->status = 0;
218
218
} else {
219
219
/* recover if the signal improves */
220
-
if (prandom_u32_max(100) <
220
+
if (get_random_u32_below(100) <
221
221
config->recover_tslock_prob_on_good_snr)
222
222
state->status = FE_HAS_SIGNAL |
223
223
FE_HAS_CARRIER |
+1
-1
drivers/media/test-drivers/vivid/vivid-kthread-cap.c
+1
-1
drivers/media/test-drivers/vivid/vivid-kthread-cap.c
+1
-1
drivers/media/test-drivers/vivid/vivid-kthread-out.c
+1
-1
drivers/media/test-drivers/vivid/vivid-kthread-out.c
+2
-2
drivers/media/test-drivers/vivid/vivid-radio-rx.c
+2
-2
drivers/media/test-drivers/vivid/vivid-radio-rx.c
···
94
94
95
95
if (data_blk == 0 && dev->radio_rds_loop)
96
96
vivid_radio_rds_init(dev);
97
-
if (perc && prandom_u32_max(100) < perc) {
98
-
switch (prandom_u32_max(4)) {
97
+
if (perc && get_random_u32_below(100) < perc) {
98
+
switch (get_random_u32_below(4)) {
99
99
case 0:
100
100
rds.block |= V4L2_RDS_BLOCK_CORRECTED;
101
101
break;
+1
-1
drivers/media/test-drivers/vivid/vivid-sdr-cap.c
+1
-1
drivers/media/test-drivers/vivid/vivid-sdr-cap.c
+1
-1
drivers/media/test-drivers/vivid/vivid-touch-cap.c
+1
-1
drivers/media/test-drivers/vivid/vivid-touch-cap.c
+2
-2
drivers/mmc/core/core.c
+2
-2
drivers/mmc/core/core.c
···
97
97
!should_fail(&host->fail_mmc_request, data->blksz * data->blocks))
98
98
return;
99
99
100
-
data->error = data_errors[prandom_u32_max(ARRAY_SIZE(data_errors))];
101
-
data->bytes_xfered = prandom_u32_max(data->bytes_xfered >> 9) << 9;
100
+
data->error = data_errors[get_random_u32_below(ARRAY_SIZE(data_errors))];
101
+
data->bytes_xfered = get_random_u32_below(data->bytes_xfered >> 9) << 9;
102
102
}
103
103
104
104
#else /* CONFIG_FAIL_MMC_REQUEST */
+1
-1
drivers/mmc/host/dw_mmc.c
+1
-1
drivers/mmc/host/dw_mmc.c
+2
-2
drivers/mtd/nand/raw/nandsim.c
+2
-2
drivers/mtd/nand/raw/nandsim.c
···
1405
1405
if (bitflips && get_random_u16() < (1 << 6)) {
1406
1406
int flips = 1;
1407
1407
if (bitflips > 1)
1408
-
flips = prandom_u32_max(bitflips) + 1;
1408
+
flips = get_random_u32_below(bitflips) + 1;
1409
1409
while (flips--) {
1410
-
int pos = prandom_u32_max(num * 8);
1410
+
int pos = get_random_u32_below(num * 8);
1411
1411
ns->buf.byte[pos / 8] ^= (1 << (pos % 8));
1412
1412
NS_WARN("read_page: flipping bit %d in page %d "
1413
1413
"reading from %d ecc: corrected=%u failed=%u\n",
+5
-5
drivers/mtd/tests/mtd_nandecctest.c
+5
-5
drivers/mtd/tests/mtd_nandecctest.c
···
47
47
static void single_bit_error_data(void *error_data, void *correct_data,
48
48
size_t size)
49
49
{
50
-
unsigned int offset = prandom_u32_max(size * BITS_PER_BYTE);
50
+
unsigned int offset = get_random_u32_below(size * BITS_PER_BYTE);
51
51
52
52
memcpy(error_data, correct_data, size);
53
53
__change_bit_le(offset, error_data);
···
58
58
{
59
59
unsigned int offset[2];
60
60
61
-
offset[0] = prandom_u32_max(size * BITS_PER_BYTE);
61
+
offset[0] = get_random_u32_below(size * BITS_PER_BYTE);
62
62
do {
63
-
offset[1] = prandom_u32_max(size * BITS_PER_BYTE);
63
+
offset[1] = get_random_u32_below(size * BITS_PER_BYTE);
64
64
} while (offset[0] == offset[1]);
65
65
66
66
memcpy(error_data, correct_data, size);
···
71
71
72
72
static unsigned int random_ecc_bit(size_t size)
73
73
{
74
-
unsigned int offset = prandom_u32_max(3 * BITS_PER_BYTE);
74
+
unsigned int offset = get_random_u32_below(3 * BITS_PER_BYTE);
75
75
76
76
if (size == 256) {
77
77
/*
···
79
79
* and 17th bit) in ECC code for 256 byte data block
80
80
*/
81
81
while (offset == 16 || offset == 17)
82
-
offset = prandom_u32_max(3 * BITS_PER_BYTE);
82
+
offset = get_random_u32_below(3 * BITS_PER_BYTE);
83
83
}
84
84
85
85
return offset;
+4
-4
drivers/mtd/tests/stresstest.c
+4
-4
drivers/mtd/tests/stresstest.c
···
46
46
47
47
again:
48
48
/* Read or write up 2 eraseblocks at a time - hence 'ebcnt - 1' */
49
-
eb = prandom_u32_max(ebcnt - 1);
49
+
eb = get_random_u32_below(ebcnt - 1);
50
50
if (bbt[eb])
51
51
goto again;
52
52
return eb;
···
54
54
55
55
static int rand_offs(void)
56
56
{
57
-
return prandom_u32_max(bufsize);
57
+
return get_random_u32_below(bufsize);
58
58
}
59
59
60
60
static int rand_len(int offs)
61
61
{
62
-
return prandom_u32_max(bufsize - offs);
62
+
return get_random_u32_below(bufsize - offs);
63
63
}
64
64
65
65
static int do_read(void)
···
118
118
119
119
static int do_operation(void)
120
120
{
121
-
if (prandom_u32_max(2))
121
+
if (get_random_u32_below(2))
122
122
return do_read();
123
123
else
124
124
return do_write();
+1
-1
drivers/mtd/ubi/debug.c
+1
-1
drivers/mtd/ubi/debug.c
···
590
590
591
591
if (ubi->dbg.power_cut_max > ubi->dbg.power_cut_min) {
592
592
range = ubi->dbg.power_cut_max - ubi->dbg.power_cut_min;
593
-
ubi->dbg.power_cut_counter += prandom_u32_max(range);
593
+
ubi->dbg.power_cut_counter += get_random_u32_below(range);
594
594
}
595
595
return 0;
596
596
}
+3
-3
drivers/mtd/ubi/debug.h
+3
-3
drivers/mtd/ubi/debug.h
···
73
73
static inline int ubi_dbg_is_bitflip(const struct ubi_device *ubi)
74
74
{
75
75
if (ubi->dbg.emulate_bitflips)
76
-
return !prandom_u32_max(200);
76
+
return !get_random_u32_below(200);
77
77
return 0;
78
78
}
79
79
···
87
87
static inline int ubi_dbg_is_write_failure(const struct ubi_device *ubi)
88
88
{
89
89
if (ubi->dbg.emulate_io_failures)
90
-
return !prandom_u32_max(500);
90
+
return !get_random_u32_below(500);
91
91
return 0;
92
92
}
93
93
···
101
101
static inline int ubi_dbg_is_erase_failure(const struct ubi_device *ubi)
102
102
{
103
103
if (ubi->dbg.emulate_io_failures)
104
-
return !prandom_u32_max(400);
104
+
return !get_random_u32_below(400);
105
105
return 0;
106
106
}
107
107
+1
-1
drivers/net/ethernet/broadcom/cnic.c
+1
-1
drivers/net/ethernet/broadcom/cnic.c
···
4105
4105
for (i = 0; i < MAX_CM_SK_TBL_SZ; i++)
4106
4106
atomic_set(&cp->csk_tbl[i].ref_count, 0);
4107
4107
4108
-
port_id = prandom_u32_max(CNIC_LOCAL_PORT_RANGE);
4108
+
port_id = get_random_u32_below(CNIC_LOCAL_PORT_RANGE);
4109
4109
if (cnic_init_id_tbl(&cp->csk_port_tbl, CNIC_LOCAL_PORT_RANGE,
4110
4110
CNIC_LOCAL_PORT_MIN, port_id)) {
4111
4111
cnic_cm_free_mem(dev);
+2
-2
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c
+2
-2
drivers/net/ethernet/chelsio/inline_crypto/chtls/chtls_io.c
···
919
919
current_timeo = *timeo_p;
920
920
noblock = (*timeo_p ? false : true);
921
921
if (csk_mem_free(cdev, sk)) {
922
-
current_timeo = prandom_u32_max(HZ / 5) + 2;
923
-
vm_wait = prandom_u32_max(HZ / 5) + 2;
922
+
current_timeo = get_random_u32_below(HZ / 5) + 2;
923
+
vm_wait = get_random_u32_below(HZ / 5) + 2;
924
924
}
925
925
926
926
add_wait_queue(sk_sleep(sk), &wait);
+1
-1
drivers/net/phy/at803x.c
+1
-1
drivers/net/phy/at803x.c
···
1758
1758
1759
1759
static int qca808x_phy_ms_random_seed_set(struct phy_device *phydev)
1760
1760
{
1761
-
u16 seed_value = prandom_u32_max(QCA808X_MASTER_SLAVE_SEED_RANGE);
1761
+
u16 seed_value = get_random_u32_below(QCA808X_MASTER_SLAVE_SEED_RANGE);
1762
1762
1763
1763
return at803x_debug_reg_mask(phydev, QCA808X_PHY_DEBUG_LOCAL_SEED,
1764
1764
QCA808X_MASTER_SLAVE_SEED_CFG,
+1
-1
drivers/net/team/team_mode_random.c
+1
-1
drivers/net/team/team_mode_random.c
+10
-10
drivers/net/wireguard/selftest/allowedips.c
+10
-10
drivers/net/wireguard/selftest/allowedips.c
···
285
285
286
286
for (i = 0; i < NUM_RAND_ROUTES; ++i) {
287
287
get_random_bytes(ip, 4);
288
-
cidr = prandom_u32_max(32) + 1;
289
-
peer = peers[prandom_u32_max(NUM_PEERS)];
288
+
cidr = get_random_u32_below(32) + 1;
289
+
peer = peers[get_random_u32_below(NUM_PEERS)];
290
290
if (wg_allowedips_insert_v4(&t, (struct in_addr *)ip, cidr,
291
291
peer, &mutex) < 0) {
292
292
pr_err("allowedips random self-test malloc: FAIL\n");
···
300
300
for (j = 0; j < NUM_MUTATED_ROUTES; ++j) {
301
301
memcpy(mutated, ip, 4);
302
302
get_random_bytes(mutate_mask, 4);
303
-
mutate_amount = prandom_u32_max(32);
303
+
mutate_amount = get_random_u32_below(32);
304
304
for (k = 0; k < mutate_amount / 8; ++k)
305
305
mutate_mask[k] = 0xff;
306
306
mutate_mask[k] = 0xff
···
311
311
mutated[k] = (mutated[k] & mutate_mask[k]) |
312
312
(~mutate_mask[k] &
313
313
get_random_u8());
314
-
cidr = prandom_u32_max(32) + 1;
315
-
peer = peers[prandom_u32_max(NUM_PEERS)];
314
+
cidr = get_random_u32_below(32) + 1;
315
+
peer = peers[get_random_u32_below(NUM_PEERS)];
316
316
if (wg_allowedips_insert_v4(&t,
317
317
(struct in_addr *)mutated,
318
318
cidr, peer, &mutex) < 0) {
···
329
329
330
330
for (i = 0; i < NUM_RAND_ROUTES; ++i) {
331
331
get_random_bytes(ip, 16);
332
-
cidr = prandom_u32_max(128) + 1;
333
-
peer = peers[prandom_u32_max(NUM_PEERS)];
332
+
cidr = get_random_u32_below(128) + 1;
333
+
peer = peers[get_random_u32_below(NUM_PEERS)];
334
334
if (wg_allowedips_insert_v6(&t, (struct in6_addr *)ip, cidr,
335
335
peer, &mutex) < 0) {
336
336
pr_err("allowedips random self-test malloc: FAIL\n");
···
344
344
for (j = 0; j < NUM_MUTATED_ROUTES; ++j) {
345
345
memcpy(mutated, ip, 16);
346
346
get_random_bytes(mutate_mask, 16);
347
-
mutate_amount = prandom_u32_max(128);
347
+
mutate_amount = get_random_u32_below(128);
348
348
for (k = 0; k < mutate_amount / 8; ++k)
349
349
mutate_mask[k] = 0xff;
350
350
mutate_mask[k] = 0xff
···
355
355
mutated[k] = (mutated[k] & mutate_mask[k]) |
356
356
(~mutate_mask[k] &
357
357
get_random_u8());
358
-
cidr = prandom_u32_max(128) + 1;
359
-
peer = peers[prandom_u32_max(NUM_PEERS)];
358
+
cidr = get_random_u32_below(128) + 1;
359
+
peer = peers[get_random_u32_below(NUM_PEERS)];
360
360
if (wg_allowedips_insert_v6(&t,
361
361
(struct in6_addr *)mutated,
362
362
cidr, peer, &mutex) < 0) {
+2
-2
drivers/net/wireguard/timers.c
+2
-2
drivers/net/wireguard/timers.c
···
147
147
if (!timer_pending(&peer->timer_new_handshake))
148
148
mod_peer_timer(peer, &peer->timer_new_handshake,
149
149
jiffies + (KEEPALIVE_TIMEOUT + REKEY_TIMEOUT) * HZ +
150
-
prandom_u32_max(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
150
+
get_random_u32_below(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
151
151
}
152
152
153
153
/* Should be called after an authenticated data packet is received. */
···
183
183
{
184
184
mod_peer_timer(peer, &peer->timer_retransmit_handshake,
185
185
jiffies + REKEY_TIMEOUT * HZ +
186
-
prandom_u32_max(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
186
+
get_random_u32_below(REKEY_TIMEOUT_JITTER_MAX_JIFFIES));
187
187
}
188
188
189
189
/* Should be called after a handshake response message is received and processed
+1
-1
drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
+1
-1
drivers/net/wireless/broadcom/brcm80211/brcmfmac/p2p.c
···
1128
1128
if (afx_hdl->is_listen && afx_hdl->my_listen_chan)
1129
1129
/* 100ms ~ 300ms */
1130
1130
err = brcmf_p2p_discover_listen(p2p, afx_hdl->my_listen_chan,
1131
-
100 * (1 + prandom_u32_max(3)));
1131
+
100 * (1 + get_random_u32_below(3)));
1132
1132
else
1133
1133
err = brcmf_p2p_act_frm_search(p2p, afx_hdl->peer_listen_chan);
1134
1134
+1
-1
drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
+1
-1
drivers/net/wireless/intel/iwlwifi/mvm/mac-ctxt.c
···
1099
1099
iwl_mvm_mac_ap_iterator, &data);
1100
1100
1101
1101
if (data.beacon_device_ts) {
1102
-
u32 rand = prandom_u32_max(64 - 36) + 36;
1102
+
u32 rand = get_random_u32_below(64 - 36) + 36;
1103
1103
mvmvif->ap_beacon_time = data.beacon_device_ts +
1104
1104
ieee80211_tu_to_usec(data.beacon_int * rand /
1105
1105
100);
+1
-1
drivers/pci/p2pdma.c
+1
-1
drivers/pci/p2pdma.c
+1
-1
drivers/s390/scsi/zfcp_fc.c
+1
-1
drivers/s390/scsi/zfcp_fc.c
+2
-2
drivers/scsi/fcoe/fcoe_ctlr.c
+2
-2
drivers/scsi/fcoe/fcoe_ctlr.c
···
2233
2233
2234
2234
if (fip->probe_tries < FIP_VN_RLIM_COUNT) {
2235
2235
fip->probe_tries++;
2236
-
wait = prandom_u32_max(FIP_VN_PROBE_WAIT);
2236
+
wait = get_random_u32_below(FIP_VN_PROBE_WAIT);
2237
2237
} else
2238
2238
wait = FIP_VN_RLIM_INT;
2239
2239
mod_timer(&fip->timer, jiffies + msecs_to_jiffies(wait));
···
3125
3125
fcoe_all_vn2vn, 0);
3126
3126
fip->port_ka_time = jiffies +
3127
3127
msecs_to_jiffies(FIP_VN_BEACON_INT +
3128
-
prandom_u32_max(FIP_VN_BEACON_FUZZ));
3128
+
get_random_u32_below(FIP_VN_BEACON_FUZZ));
3129
3129
}
3130
3130
if (time_before(fip->port_ka_time, next_time))
3131
3131
next_time = fip->port_ka_time;
+1
-1
drivers/scsi/qedi/qedi_main.c
+1
-1
drivers/scsi/qedi/qedi_main.c
···
618
618
sizeof(struct qedi_endpoint *)), GFP_KERNEL);
619
619
if (!qedi->ep_tbl)
620
620
return -ENOMEM;
621
-
port_id = prandom_u32_max(QEDI_LOCAL_PORT_RANGE);
621
+
port_id = get_random_u32_below(QEDI_LOCAL_PORT_RANGE);
622
622
if (qedi_init_id_tbl(&qedi->lcl_port_tbl, QEDI_LOCAL_PORT_RANGE,
623
623
QEDI_LOCAL_PORT_MIN, port_id)) {
624
624
qedi_cm_free_mem(qedi);
+3
-3
drivers/scsi/scsi_debug.c
+3
-3
drivers/scsi/scsi_debug.c
···
5702
5702
u64 ns = jiffies_to_nsecs(delta_jiff);
5703
5703
5704
5704
if (sdebug_random && ns < U32_MAX) {
5705
-
ns = prandom_u32_max((u32)ns);
5705
+
ns = get_random_u32_below((u32)ns);
5706
5706
} else if (sdebug_random) {
5707
5707
ns >>= 12; /* scale to 4 usec precision */
5708
5708
if (ns < U32_MAX) /* over 4 hours max */
5709
-
ns = prandom_u32_max((u32)ns);
5709
+
ns = get_random_u32_below((u32)ns);
5710
5710
ns <<= 12;
5711
5711
}
5712
5712
kt = ns_to_ktime(ns);
5713
5713
} else { /* ndelay has a 4.2 second max */
5714
-
kt = sdebug_random ? prandom_u32_max((u32)ndelay) :
5714
+
kt = sdebug_random ? get_random_u32_below((u32)ndelay) :
5715
5715
(u32)ndelay;
5716
5716
if (ndelay < INCLUSIVE_TIMING_MAX_NS) {
5717
5717
u64 d = ktime_get_boottime_ns() - ns_from_boot;
+1
-1
fs/ceph/inode.c
+1
-1
fs/ceph/inode.c
+1
-1
fs/ceph/mdsmap.c
+1
-1
fs/ceph/mdsmap.c
+1
-1
fs/ext2/ialloc.c
+1
-1
fs/ext2/ialloc.c
···
277
277
int best_ndir = inodes_per_group;
278
278
int best_group = -1;
279
279
280
-
parent_group = prandom_u32_max(ngroups);
280
+
parent_group = get_random_u32_below(ngroups);
281
281
for (i = 0; i < ngroups; i++) {
282
282
group = (parent_group + i) % ngroups;
283
283
desc = ext2_get_group_desc (sb, group, NULL);
+1
-1
fs/ext4/ialloc.c
+1
-1
fs/ext4/ialloc.c
···
465
465
ext4fs_dirhash(parent, qstr->name, qstr->len, &hinfo);
466
466
parent_group = hinfo.hash % ngroups;
467
467
} else
468
-
parent_group = prandom_u32_max(ngroups);
468
+
parent_group = get_random_u32_below(ngroups);
469
469
for (i = 0; i < ngroups; i++) {
470
470
g = (parent_group + i) % ngroups;
471
471
get_orlov_stats(sb, g, flex_size, &stats);
+2
-3
fs/ext4/super.c
+2
-3
fs/ext4/super.c
···
3778
3778
}
3779
3779
if (!progress) {
3780
3780
elr->lr_next_sched = jiffies +
3781
-
prandom_u32_max(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3781
+
get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3782
3782
}
3783
3783
if (time_before(elr->lr_next_sched, next_wakeup))
3784
3784
next_wakeup = elr->lr_next_sched;
···
3925
3925
* spread the inode table initialization requests
3926
3926
* better.
3927
3927
*/
3928
-
elr->lr_next_sched = jiffies + prandom_u32_max(
3929
-
EXT4_DEF_LI_MAX_START_DELAY * HZ);
3928
+
elr->lr_next_sched = jiffies + get_random_u32_below(EXT4_DEF_LI_MAX_START_DELAY * HZ);
3930
3929
return elr;
3931
3930
}
3932
3931
+1
-1
fs/f2fs/gc.c
+1
-1
fs/f2fs/gc.c
···
282
282
283
283
/* let's select beginning hot/small space first in no_heap mode*/
284
284
if (f2fs_need_rand_seg(sbi))
285
-
p->offset = prandom_u32_max(MAIN_SECS(sbi) * sbi->segs_per_sec);
285
+
p->offset = get_random_u32_below(MAIN_SECS(sbi) * sbi->segs_per_sec);
286
286
else if (test_opt(sbi, NOHEAP) &&
287
287
(type == CURSEG_HOT_DATA || IS_NODESEG(type)))
288
288
p->offset = 0;
+4
-4
fs/f2fs/segment.c
+4
-4
fs/f2fs/segment.c
···
2534
2534
2535
2535
sanity_check_seg_type(sbi, seg_type);
2536
2536
if (f2fs_need_rand_seg(sbi))
2537
-
return prandom_u32_max(MAIN_SECS(sbi) * sbi->segs_per_sec);
2537
+
return get_random_u32_below(MAIN_SECS(sbi) * sbi->segs_per_sec);
2538
2538
2539
2539
/* if segs_per_sec is large than 1, we need to keep original policy. */
2540
2540
if (__is_large_section(sbi))
···
2588
2588
curseg->alloc_type = LFS;
2589
2589
if (F2FS_OPTION(sbi).fs_mode == FS_MODE_FRAGMENT_BLK)
2590
2590
curseg->fragment_remained_chunk =
2591
-
prandom_u32_max(sbi->max_fragment_chunk) + 1;
2591
+
get_random_u32_below(sbi->max_fragment_chunk) + 1;
2592
2592
}
2593
2593
2594
2594
static int __next_free_blkoff(struct f2fs_sb_info *sbi,
···
2625
2625
/* To allocate block chunks in different sizes, use random number */
2626
2626
if (--seg->fragment_remained_chunk <= 0) {
2627
2627
seg->fragment_remained_chunk =
2628
-
prandom_u32_max(sbi->max_fragment_chunk) + 1;
2628
+
get_random_u32_below(sbi->max_fragment_chunk) + 1;
2629
2629
seg->next_blkoff +=
2630
-
prandom_u32_max(sbi->max_fragment_hole) + 1;
2630
+
get_random_u32_below(sbi->max_fragment_hole) + 1;
2631
2631
}
2632
2632
}
2633
2633
}
+4
-4
fs/ubifs/debug.c
+4
-4
fs/ubifs/debug.c
···
2467
2467
2468
2468
static inline int chance(unsigned int n, unsigned int out_of)
2469
2469
{
2470
-
return !!(prandom_u32_max(out_of) + 1 <= n);
2470
+
return !!(get_random_u32_below(out_of) + 1 <= n);
2471
2471
2472
2472
}
2473
2473
···
2485
2485
if (chance(1, 2)) {
2486
2486
d->pc_delay = 1;
2487
2487
/* Fail within 1 minute */
2488
-
delay = prandom_u32_max(60000);
2488
+
delay = get_random_u32_below(60000);
2489
2489
d->pc_timeout = jiffies;
2490
2490
d->pc_timeout += msecs_to_jiffies(delay);
2491
2491
ubifs_warn(c, "failing after %lums", delay);
2492
2492
} else {
2493
2493
d->pc_delay = 2;
2494
-
delay = prandom_u32_max(10000);
2494
+
delay = get_random_u32_below(10000);
2495
2495
/* Fail within 10000 operations */
2496
2496
d->pc_cnt_max = delay;
2497
2497
ubifs_warn(c, "failing after %lu calls", delay);
···
2571
2571
unsigned int from, to, ffs = chance(1, 2);
2572
2572
unsigned char *p = (void *)buf;
2573
2573
2574
-
from = prandom_u32_max(len);
2574
+
from = get_random_u32_below(len);
2575
2575
/* Corruption span max to end of write unit */
2576
2576
to = min(len, ALIGN(from + 1, c->max_write_size));
2577
2577
+7
-7
fs/ubifs/lpt_commit.c
+7
-7
fs/ubifs/lpt_commit.c
···
1970
1970
1971
1971
if (!dbg_is_chk_gen(c))
1972
1972
return 0;
1973
-
if (prandom_u32_max(4))
1973
+
if (get_random_u32_below(4))
1974
1974
return 0;
1975
1975
1976
1976
for (i = 0; i < c->lsave_cnt; i++)
1977
1977
c->lsave[i] = c->main_first;
1978
1978
1979
1979
list_for_each_entry(lprops, &c->empty_list, list)
1980
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = lprops->lnum;
1980
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = lprops->lnum;
1981
1981
list_for_each_entry(lprops, &c->freeable_list, list)
1982
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = lprops->lnum;
1982
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = lprops->lnum;
1983
1983
list_for_each_entry(lprops, &c->frdi_idx_list, list)
1984
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = lprops->lnum;
1984
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = lprops->lnum;
1985
1985
1986
1986
heap = &c->lpt_heap[LPROPS_DIRTY_IDX - 1];
1987
1987
for (i = 0; i < heap->cnt; i++)
1988
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = heap->arr[i]->lnum;
1988
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = heap->arr[i]->lnum;
1989
1989
heap = &c->lpt_heap[LPROPS_DIRTY - 1];
1990
1990
for (i = 0; i < heap->cnt; i++)
1991
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = heap->arr[i]->lnum;
1991
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = heap->arr[i]->lnum;
1992
1992
heap = &c->lpt_heap[LPROPS_FREE - 1];
1993
1993
for (i = 0; i < heap->cnt; i++)
1994
-
c->lsave[prandom_u32_max(c->lsave_cnt)] = heap->arr[i]->lnum;
1994
+
c->lsave[get_random_u32_below(c->lsave_cnt)] = heap->arr[i]->lnum;
1995
1995
1996
1996
return 1;
1997
1997
}
+1
-1
fs/ubifs/tnc_commit.c
+1
-1
fs/ubifs/tnc_commit.c
+1
-1
fs/xfs/libxfs/xfs_alloc.c
+1
-1
fs/xfs/libxfs/xfs_alloc.c
+1
-1
fs/xfs/libxfs/xfs_ialloc.c
+1
-1
fs/xfs/libxfs/xfs_ialloc.c
+1
-1
fs/xfs/xfs_error.c
+1
-1
fs/xfs/xfs_error.c
+1
-1
include/linux/damon.h
+1
-1
include/linux/damon.h
+1
-1
include/linux/nodemask.h
+1
-1
include/linux/nodemask.h
+2
-2
kernel/bpf/core.c
+2
-2
kernel/bpf/core.c
···
1032
1032
hdr->size = size;
1033
1033
hole = min_t(unsigned int, size - (proglen + sizeof(*hdr)),
1034
1034
PAGE_SIZE - sizeof(*hdr));
1035
-
start = prandom_u32_max(hole) & ~(alignment - 1);
1035
+
start = get_random_u32_below(hole) & ~(alignment - 1);
1036
1036
1037
1037
/* Leave a random number of instructions before BPF code. */
1038
1038
*image_ptr = &hdr->image[start];
···
1094
1094
1095
1095
hole = min_t(unsigned int, size - (proglen + sizeof(*ro_header)),
1096
1096
BPF_PROG_CHUNK_SIZE - sizeof(*ro_header));
1097
-
start = prandom_u32_max(hole) & ~(alignment - 1);
1097
+
start = get_random_u32_below(hole) & ~(alignment - 1);
1098
1098
1099
1099
*image_ptr = &ro_header->image[start];
1100
1100
*rw_image = &(*rw_header)->image[start];
+2
-2
kernel/kcsan/selftest.c
+2
-2
kernel/kcsan/selftest.c
···
31
31
int i;
32
32
33
33
for (i = 0; i < ITERS_PER_TEST; ++i) {
34
-
size_t size = prandom_u32_max(MAX_ENCODABLE_SIZE) + 1;
35
-
bool is_write = !!prandom_u32_max(2);
34
+
size_t size = get_random_u32_below(MAX_ENCODABLE_SIZE) + 1;
35
+
bool is_write = !!get_random_u32_below(2);
36
36
unsigned long verif_masked_addr;
37
37
long encoded_watchpoint;
38
38
bool verif_is_write;
+2
-2
kernel/locking/test-ww_mutex.c
+2
-2
kernel/locking/test-ww_mutex.c
···
399
399
order[n] = n;
400
400
401
401
for (n = count - 1; n > 1; n--) {
402
-
r = prandom_u32_max(n + 1);
402
+
r = get_random_u32_below(n + 1);
403
403
if (r != n) {
404
404
tmp = order[n];
405
405
order[n] = order[r];
···
538
538
{
539
539
struct stress *stress = container_of(work, typeof(*stress), work);
540
540
const int nlocks = stress->nlocks;
541
-
struct ww_mutex *lock = stress->locks + prandom_u32_max(nlocks);
541
+
struct ww_mutex *lock = stress->locks + get_random_u32_below(nlocks);
542
542
int err;
543
543
544
544
do {
+1
-1
kernel/time/clocksource.c
+1
-1
kernel/time/clocksource.c
···
310
310
* CPUs that are currently online.
311
311
*/
312
312
for (i = 1; i < n; i++) {
313
-
cpu = prandom_u32_max(nr_cpu_ids);
313
+
cpu = get_random_u32_below(nr_cpu_ids);
314
314
cpu = cpumask_next(cpu - 1, cpu_online_mask);
315
315
if (cpu >= nr_cpu_ids)
316
316
cpu = cpumask_first(cpu_online_mask);
+1
-1
lib/fault-inject.c
+1
-1
lib/fault-inject.c
+2
-2
lib/find_bit_benchmark.c
+2
-2
lib/find_bit_benchmark.c
···
174
174
bitmap_zero(bitmap2, BITMAP_LEN);
175
175
176
176
while (nbits--) {
177
-
__set_bit(prandom_u32_max(BITMAP_LEN), bitmap);
178
-
__set_bit(prandom_u32_max(BITMAP_LEN), bitmap2);
177
+
__set_bit(get_random_u32_below(BITMAP_LEN), bitmap);
178
+
__set_bit(get_random_u32_below(BITMAP_LEN), bitmap2);
179
179
}
180
180
181
181
test_find_next_bit(bitmap, BITMAP_LEN);
+1
-1
lib/kobject.c
+1
-1
lib/kobject.c
···
694
694
{
695
695
struct kobject *kobj = container_of(kref, struct kobject, kref);
696
696
#ifdef CONFIG_DEBUG_KOBJECT_RELEASE
697
-
unsigned long delay = HZ + HZ * prandom_u32_max(4);
697
+
unsigned long delay = HZ + HZ * get_random_u32_below(4);
698
698
pr_info("kobject: '%s' (%p): %s, parent %p (delayed %ld)\n",
699
699
kobject_name(kobj), kobj, __func__, kobj->parent, delay);
700
700
INIT_DELAYED_WORK(&kobj->release, kobject_delayed_cleanup);
+3
-3
lib/reed_solomon/test_rslib.c
+3
-3
lib/reed_solomon/test_rslib.c
···
183
183
184
184
do {
185
185
/* Must not choose the same location twice */
186
-
errloc = prandom_u32_max(len);
186
+
errloc = get_random_u32_below(len);
187
187
} while (errlocs[errloc] != 0);
188
188
189
189
errlocs[errloc] = 1;
···
194
194
for (i = 0; i < eras; i++) {
195
195
do {
196
196
/* Must not choose the same location twice */
197
-
errloc = prandom_u32_max(len);
197
+
errloc = get_random_u32_below(len);
198
198
} while (errlocs[errloc] != 0);
199
199
200
200
derrlocs[i] = errloc;
201
201
202
-
if (ewsc && prandom_u32_max(2)) {
202
+
if (ewsc && get_random_u32_below(2)) {
203
203
/* Erasure with the symbol intact */
204
204
errlocs[errloc] = 2;
205
205
} else {
+2
-2
lib/sbitmap.c
+2
-2
lib/sbitmap.c
···
21
21
int i;
22
22
23
23
for_each_possible_cpu(i)
24
-
*per_cpu_ptr(sb->alloc_hint, i) = prandom_u32_max(depth);
24
+
*per_cpu_ptr(sb->alloc_hint, i) = get_random_u32_below(depth);
25
25
}
26
26
return 0;
27
27
}
···
33
33
34
34
hint = this_cpu_read(*sb->alloc_hint);
35
35
if (unlikely(hint >= depth)) {
36
-
hint = depth ? prandom_u32_max(depth) : 0;
36
+
hint = depth ? get_random_u32_below(depth) : 0;
37
37
this_cpu_write(*sb->alloc_hint, hint);
38
38
}
39
39
+1
-1
lib/test-string_helpers.c
+1
-1
lib/test-string_helpers.c
···
587
587
for (i = 0; i < UNESCAPE_ALL_MASK + 1; i++)
588
588
test_string_unescape("unescape", i, false);
589
589
test_string_unescape("unescape inplace",
590
-
prandom_u32_max(UNESCAPE_ANY + 1), true);
590
+
get_random_u32_below(UNESCAPE_ANY + 1), true);
591
591
592
592
/* Without dictionary */
593
593
for (i = 0; i < ESCAPE_ALL_MASK + 1; i++)
+5
-5
lib/test_hexdump.c
+5
-5
lib/test_hexdump.c
···
149
149
static void __init test_hexdump_set(int rowsize, bool ascii)
150
150
{
151
151
size_t d = min_t(size_t, sizeof(data_b), rowsize);
152
-
size_t len = prandom_u32_max(d) + 1;
152
+
size_t len = get_random_u32_below(d) + 1;
153
153
154
154
test_hexdump(len, rowsize, 4, ascii);
155
155
test_hexdump(len, rowsize, 2, ascii);
···
208
208
static void __init test_hexdump_overflow_set(size_t buflen, bool ascii)
209
209
{
210
210
unsigned int i = 0;
211
-
int rs = (prandom_u32_max(2) + 1) * 16;
211
+
int rs = (get_random_u32_below(2) + 1) * 16;
212
212
213
213
do {
214
214
int gs = 1 << i;
215
-
size_t len = prandom_u32_max(rs) + gs;
215
+
size_t len = get_random_u32_below(rs) + gs;
216
216
217
217
test_hexdump_overflow(buflen, rounddown(len, gs), rs, gs, ascii);
218
218
} while (i++ < 3);
···
223
223
unsigned int i;
224
224
int rowsize;
225
225
226
-
rowsize = (prandom_u32_max(2) + 1) * 16;
226
+
rowsize = (get_random_u32_below(2) + 1) * 16;
227
227
for (i = 0; i < 16; i++)
228
228
test_hexdump_set(rowsize, false);
229
229
230
-
rowsize = (prandom_u32_max(2) + 1) * 16;
230
+
rowsize = (get_random_u32_below(2) + 1) * 16;
231
231
for (i = 0; i < 16; i++)
232
232
test_hexdump_set(rowsize, true);
233
233
+1
-1
lib/test_list_sort.c
+1
-1
lib/test_list_sort.c
+1
-1
lib/test_printf.c
+1
-1
lib/test_printf.c
···
126
126
* be able to print it as expected.
127
127
*/
128
128
failed_tests += do_test(BUF_SIZE, expect, elen, fmt, ap);
129
-
rand = 1 + prandom_u32_max(elen+1);
129
+
rand = 1 + get_random_u32_below(elen + 1);
130
130
/* Since elen < BUF_SIZE, we have 1 <= rand <= BUF_SIZE. */
131
131
failed_tests += do_test(rand, expect, elen, fmt, ap);
132
132
failed_tests += do_test(0, expect, elen, fmt, ap);
+3
-3
lib/test_rhashtable.c
+3
-3
lib/test_rhashtable.c
···
368
368
369
369
pr_info("test %d random rhlist add/delete operations\n", entries);
370
370
for (j = 0; j < entries; j++) {
371
-
u32 i = prandom_u32_max(entries);
372
-
u32 prand = prandom_u32_max(4);
371
+
u32 i = get_random_u32_below(entries);
372
+
u32 prand = get_random_u32_below(4);
373
373
374
374
cond_resched();
375
375
···
396
396
}
397
397
398
398
if (prand & 2) {
399
-
i = prandom_u32_max(entries);
399
+
i = get_random_u32_below(entries);
400
400
if (test_bit(i, obj_in_table)) {
401
401
err = rhltable_remove(&rhlt, &rhl_test_objects[i].list_node, test_rht_params);
402
402
WARN(err, "cannot remove element at slot %d", i);
+4
-4
lib/test_vmalloc.c
+4
-4
lib/test_vmalloc.c
···
151
151
int i;
152
152
153
153
for (i = 0; i < test_loop_count; i++) {
154
-
n = prandom_u32_max(100) + 1;
154
+
n = get_random_u32_below(100) + 1;
155
155
p = vmalloc(n * PAGE_SIZE);
156
156
157
157
if (!p)
···
291
291
return -1;
292
292
293
293
for (i = 0; i < 35000; i++) {
294
-
size = prandom_u32_max(PAGE_SIZE / 4) + 1;
294
+
size = get_random_u32_below(PAGE_SIZE / 4) + 1;
295
295
296
296
/*
297
297
* Maximum PAGE_SIZE
298
298
*/
299
-
align = 1 << (prandom_u32_max(11) + 1);
299
+
align = 1 << (get_random_u32_below(11) + 1);
300
300
301
301
pcpu[i] = __alloc_percpu(size, align);
302
302
if (!pcpu[i])
···
391
391
392
392
for (i = n - 1; i > 0; i--) {
393
393
/* Cut the range. */
394
-
j = prandom_u32_max(i);
394
+
j = get_random_u32_below(i);
395
395
396
396
/* Swap indexes. */
397
397
swap(arr[i], arr[j]);
+3
-3
mm/kasan/kasan_test.c
+3
-3
mm/kasan/kasan_test.c
···
1299
1299
KASAN_TEST_NEEDS_CONFIG_OFF(test, CONFIG_KASAN_GENERIC);
1300
1300
1301
1301
for (i = 0; i < 256; i++) {
1302
-
size = prandom_u32_max(1024) + 1;
1302
+
size = get_random_u32_below(1024) + 1;
1303
1303
ptr = kmalloc(size, GFP_KERNEL);
1304
1304
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1305
1305
KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
···
1308
1308
}
1309
1309
1310
1310
for (i = 0; i < 256; i++) {
1311
-
order = prandom_u32_max(4) + 1;
1311
+
order = get_random_u32_below(4) + 1;
1312
1312
pages = alloc_pages(GFP_KERNEL, order);
1313
1313
ptr = page_address(pages);
1314
1314
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
···
1321
1321
return;
1322
1322
1323
1323
for (i = 0; i < 256; i++) {
1324
-
size = prandom_u32_max(1024) + 1;
1324
+
size = get_random_u32_below(1024) + 1;
1325
1325
ptr = vmalloc(size);
1326
1326
KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ptr);
1327
1327
KUNIT_EXPECT_GE(test, (u8)get_tag(ptr), (u8)KASAN_TAG_MIN);
+2
-2
mm/kfence/core.c
+2
-2
mm/kfence/core.c
···
360
360
unsigned long flags;
361
361
struct slab *slab;
362
362
void *addr;
363
-
const bool random_right_allocate = prandom_u32_max(2);
363
+
const bool random_right_allocate = get_random_u32_below(2);
364
364
const bool random_fault = CONFIG_KFENCE_STRESS_TEST_FAULTS &&
365
-
!prandom_u32_max(CONFIG_KFENCE_STRESS_TEST_FAULTS);
365
+
!get_random_u32_below(CONFIG_KFENCE_STRESS_TEST_FAULTS);
366
366
367
367
/* Try to obtain a free object. */
368
368
raw_spin_lock_irqsave(&kfence_freelist_lock, flags);
+2
-2
mm/kfence/kfence_test.c
+2
-2
mm/kfence/kfence_test.c
···
532
532
int iter;
533
533
534
534
for (iter = 0; iter < 5; iter++) {
535
-
const size_t size = setup_test_cache(test, 8 + prandom_u32_max(300), 0,
536
-
(iter & 1) ? ctor_set_x : NULL);
535
+
const size_t size = setup_test_cache(test, 8 + get_random_u32_below(300),
536
+
0, (iter & 1) ? ctor_set_x : NULL);
537
537
void *objects[] = {
538
538
test_alloc(test, size, GFP_KERNEL, ALLOCATE_RIGHT),
539
539
test_alloc(test, size, GFP_KERNEL, ALLOCATE_NONE),
+1
-1
mm/slub.c
+1
-1
mm/slub.c
+2
-2
mm/swapfile.c
+2
-2
mm/swapfile.c
···
773
773
if (si->highest_bit <= si->lowest_bit)
774
774
return;
775
775
next = si->lowest_bit +
776
-
prandom_u32_max(si->highest_bit - si->lowest_bit + 1);
776
+
get_random_u32_below(si->highest_bit - si->lowest_bit + 1);
777
777
next = ALIGN_DOWN(next, SWAP_ADDRESS_SPACE_PAGES);
778
778
next = max_t(unsigned int, next, si->lowest_bit);
779
779
}
···
3089
3089
*/
3090
3090
for_each_possible_cpu(cpu) {
3091
3091
per_cpu(*p->cluster_next_cpu, cpu) =
3092
-
1 + prandom_u32_max(p->highest_bit);
3092
+
1 + get_random_u32_below(p->highest_bit);
3093
3093
}
3094
3094
nr_cluster = DIV_ROUND_UP(maxpages, SWAPFILE_CLUSTER);
3095
3095
+1
-1
net/802/garp.c
+1
-1
net/802/garp.c
+1
-1
net/802/mrp.c
+1
-1
net/802/mrp.c
+2
-2
net/batman-adv/bat_iv_ogm.c
+2
-2
net/batman-adv/bat_iv_ogm.c
···
280
280
unsigned int msecs;
281
281
282
282
msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
283
-
msecs += prandom_u32_max(2 * BATADV_JITTER);
283
+
msecs += get_random_u32_below(2 * BATADV_JITTER);
284
284
285
285
return jiffies + msecs_to_jiffies(msecs);
286
286
}
···
288
288
/* when do we schedule a ogm packet to be sent */
289
289
static unsigned long batadv_iv_ogm_fwd_send_time(void)
290
290
{
291
-
return jiffies + msecs_to_jiffies(prandom_u32_max(BATADV_JITTER / 2));
291
+
return jiffies + msecs_to_jiffies(get_random_u32_below(BATADV_JITTER / 2));
292
292
}
293
293
294
294
/* apply hop penalty for a normal link */
+1
-1
net/batman-adv/bat_v_elp.c
+1
-1
net/batman-adv/bat_v_elp.c
···
51
51
unsigned int msecs;
52
52
53
53
msecs = atomic_read(&hard_iface->bat_v.elp_interval) - BATADV_JITTER;
54
-
msecs += prandom_u32_max(2 * BATADV_JITTER);
54
+
msecs += get_random_u32_below(2 * BATADV_JITTER);
55
55
56
56
queue_delayed_work(batadv_event_workqueue, &hard_iface->bat_v.elp_wq,
57
57
msecs_to_jiffies(msecs));
+2
-2
net/batman-adv/bat_v_ogm.c
+2
-2
net/batman-adv/bat_v_ogm.c
···
90
90
unsigned int msecs = BATADV_MAX_AGGREGATION_MS * 1000;
91
91
92
92
/* msecs * [0.9, 1.1] */
93
-
msecs += prandom_u32_max(msecs / 5) - (msecs / 10);
93
+
msecs += get_random_u32_below(msecs / 5) - (msecs / 10);
94
94
queue_delayed_work(batadv_event_workqueue, &hard_iface->bat_v.aggr_wq,
95
95
msecs_to_jiffies(msecs / 1000));
96
96
}
···
109
109
return;
110
110
111
111
msecs = atomic_read(&bat_priv->orig_interval) - BATADV_JITTER;
112
-
msecs += prandom_u32_max(2 * BATADV_JITTER);
112
+
msecs += get_random_u32_below(2 * BATADV_JITTER);
113
113
queue_delayed_work(batadv_event_workqueue, &bat_priv->bat_v.ogm_wq,
114
114
msecs_to_jiffies(msecs));
115
115
}
+1
-1
net/batman-adv/network-coding.c
+1
-1
net/batman-adv/network-coding.c
···
1009
1009
static u8 batadv_nc_random_weight_tq(u8 tq)
1010
1010
{
1011
1011
/* randomize the estimated packet loss (max TQ - estimated TQ) */
1012
-
u8 rand_tq = prandom_u32_max(BATADV_TQ_MAX_VALUE + 1 - tq);
1012
+
u8 rand_tq = get_random_u32_below(BATADV_TQ_MAX_VALUE + 1 - tq);
1013
1013
1014
1014
/* convert to (randomized) estimated tq again */
1015
1015
return BATADV_TQ_MAX_VALUE - rand_tq;
+2
-2
net/bluetooth/mgmt.c
+2
-2
net/bluetooth/mgmt.c
···
7374
7374
* calculate conn info age as random value between min/max set in hdev.
7375
7375
*/
7376
7376
conn_info_age = hdev->conn_info_min_age +
7377
-
prandom_u32_max(hdev->conn_info_max_age -
7378
-
hdev->conn_info_min_age);
7377
+
get_random_u32_below(hdev->conn_info_max_age -
7378
+
hdev->conn_info_min_age);
7379
7379
7380
7380
/* Query controller to refresh cached values if they are too old or were
7381
7381
* never read.
+1
-1
net/can/j1939/socket.c
+1
-1
net/can/j1939/socket.c
+1
-1
net/can/j1939/transport.c
+1
-1
net/can/j1939/transport.c
···
1168
1168
if (session->tx_retry < J1939_XTP_TX_RETRY_LIMIT) {
1169
1169
session->tx_retry++;
1170
1170
j1939_tp_schedule_txtimer(session,
1171
-
10 + prandom_u32_max(16));
1171
+
10 + get_random_u32_below(16));
1172
1172
} else {
1173
1173
netdev_alert(priv->ndev, "%s: 0x%p: tx retry count reached\n",
1174
1174
__func__, session);
+1
-1
net/ceph/mon_client.c
+1
-1
net/ceph/mon_client.c
+1
-1
net/ceph/osd_client.c
+1
-1
net/ceph/osd_client.c
···
1479
1479
1480
1480
static int pick_random_replica(const struct ceph_osds *acting)
1481
1481
{
1482
-
int i = prandom_u32_max(acting->size);
1482
+
int i = get_random_u32_below(acting->size);
1483
1483
1484
1484
dout("%s picked osd%d, primary osd%d\n", __func__,
1485
1485
acting->osds[i], acting->primary);
+2
-2
net/core/neighbour.c
+2
-2
net/core/neighbour.c
···
111
111
112
112
unsigned long neigh_rand_reach_time(unsigned long base)
113
113
{
114
-
return base ? prandom_u32_max(base) + (base >> 1) : 0;
114
+
return base ? get_random_u32_below(base) + (base >> 1) : 0;
115
115
}
116
116
EXPORT_SYMBOL(neigh_rand_reach_time);
117
117
···
1652
1652
struct sk_buff *skb)
1653
1653
{
1654
1654
unsigned long sched_next = jiffies +
1655
-
prandom_u32_max(NEIGH_VAR(p, PROXY_DELAY));
1655
+
get_random_u32_below(NEIGH_VAR(p, PROXY_DELAY));
1656
1656
1657
1657
if (p->qlen > NEIGH_VAR(p, PROXY_QLEN)) {
1658
1658
kfree_skb(skb);
+14
-14
net/core/pktgen.c
+14
-14
net/core/pktgen.c
···
2324
2324
pkt_dev->curfl = 0; /*reset */
2325
2325
}
2326
2326
} else {
2327
-
flow = prandom_u32_max(pkt_dev->cflows);
2327
+
flow = get_random_u32_below(pkt_dev->cflows);
2328
2328
pkt_dev->curfl = flow;
2329
2329
2330
2330
if (pkt_dev->flows[flow].count > pkt_dev->lflow) {
···
2380
2380
else if (pkt_dev->queue_map_min <= pkt_dev->queue_map_max) {
2381
2381
__u16 t;
2382
2382
if (pkt_dev->flags & F_QUEUE_MAP_RND) {
2383
-
t = prandom_u32_max(pkt_dev->queue_map_max -
2384
-
pkt_dev->queue_map_min + 1) +
2383
+
t = get_random_u32_below(pkt_dev->queue_map_max -
2384
+
pkt_dev->queue_map_min + 1) +
2385
2385
pkt_dev->queue_map_min;
2386
2386
} else {
2387
2387
t = pkt_dev->cur_queue_map + 1;
···
2411
2411
__u32 tmp;
2412
2412
2413
2413
if (pkt_dev->flags & F_MACSRC_RND)
2414
-
mc = prandom_u32_max(pkt_dev->src_mac_count);
2414
+
mc = get_random_u32_below(pkt_dev->src_mac_count);
2415
2415
else {
2416
2416
mc = pkt_dev->cur_src_mac_offset++;
2417
2417
if (pkt_dev->cur_src_mac_offset >=
···
2437
2437
__u32 tmp;
2438
2438
2439
2439
if (pkt_dev->flags & F_MACDST_RND)
2440
-
mc = prandom_u32_max(pkt_dev->dst_mac_count);
2440
+
mc = get_random_u32_below(pkt_dev->dst_mac_count);
2441
2441
2442
2442
else {
2443
2443
mc = pkt_dev->cur_dst_mac_offset++;
···
2469
2469
}
2470
2470
2471
2471
if ((pkt_dev->flags & F_VID_RND) && (pkt_dev->vlan_id != 0xffff)) {
2472
-
pkt_dev->vlan_id = prandom_u32_max(4096);
2472
+
pkt_dev->vlan_id = get_random_u32_below(4096);
2473
2473
}
2474
2474
2475
2475
if ((pkt_dev->flags & F_SVID_RND) && (pkt_dev->svlan_id != 0xffff)) {
2476
-
pkt_dev->svlan_id = prandom_u32_max(4096);
2476
+
pkt_dev->svlan_id = get_random_u32_below(4096);
2477
2477
}
2478
2478
2479
2479
if (pkt_dev->udp_src_min < pkt_dev->udp_src_max) {
2480
2480
if (pkt_dev->flags & F_UDPSRC_RND)
2481
-
pkt_dev->cur_udp_src = prandom_u32_max(
2481
+
pkt_dev->cur_udp_src = get_random_u32_below(
2482
2482
pkt_dev->udp_src_max - pkt_dev->udp_src_min) +
2483
2483
pkt_dev->udp_src_min;
2484
2484
···
2491
2491
2492
2492
if (pkt_dev->udp_dst_min < pkt_dev->udp_dst_max) {
2493
2493
if (pkt_dev->flags & F_UDPDST_RND) {
2494
-
pkt_dev->cur_udp_dst = prandom_u32_max(
2494
+
pkt_dev->cur_udp_dst = get_random_u32_below(
2495
2495
pkt_dev->udp_dst_max - pkt_dev->udp_dst_min) +
2496
2496
pkt_dev->udp_dst_min;
2497
2497
} else {
···
2508
2508
if (imn < imx) {
2509
2509
__u32 t;
2510
2510
if (pkt_dev->flags & F_IPSRC_RND)
2511
-
t = prandom_u32_max(imx - imn) + imn;
2511
+
t = get_random_u32_below(imx - imn) + imn;
2512
2512
else {
2513
2513
t = ntohl(pkt_dev->cur_saddr);
2514
2514
t++;
···
2530
2530
if (pkt_dev->flags & F_IPDST_RND) {
2531
2531
2532
2532
do {
2533
-
t = prandom_u32_max(imx - imn) +
2533
+
t = get_random_u32_below(imx - imn) +
2534
2534
imn;
2535
2535
s = htonl(t);
2536
2536
} while (ipv4_is_loopback(s) ||
···
2578
2578
if (pkt_dev->min_pkt_size < pkt_dev->max_pkt_size) {
2579
2579
__u32 t;
2580
2580
if (pkt_dev->flags & F_TXSIZE_RND) {
2581
-
t = prandom_u32_max(pkt_dev->max_pkt_size -
2582
-
pkt_dev->min_pkt_size) +
2581
+
t = get_random_u32_below(pkt_dev->max_pkt_size -
2582
+
pkt_dev->min_pkt_size) +
2583
2583
pkt_dev->min_pkt_size;
2584
2584
} else {
2585
2585
t = pkt_dev->cur_pkt_size + 1;
···
2589
2589
pkt_dev->cur_pkt_size = t;
2590
2590
} else if (pkt_dev->n_imix_entries > 0) {
2591
2591
struct imix_pkt *entry;
2592
-
__u32 t = prandom_u32_max(IMIX_PRECISION);
2592
+
__u32 t = get_random_u32_below(IMIX_PRECISION);
2593
2593
__u8 entry_index = pkt_dev->imix_distribution[t];
2594
2594
2595
2595
entry = &pkt_dev->imix_entries[entry_index];
+1
-1
net/core/stream.c
+1
-1
net/core/stream.c
+1
-1
net/ipv4/icmp.c
+1
-1
net/ipv4/icmp.c
···
263
263
/* We want to use a credit of one in average, but need to randomize
264
264
* it for security reasons.
265
265
*/
266
-
credit = max_t(int, credit - prandom_u32_max(3), 0);
266
+
credit = max_t(int, credit - get_random_u32_below(3), 0);
267
267
rc = true;
268
268
}
269
269
WRITE_ONCE(icmp_global.credit, credit);
+3
-3
net/ipv4/igmp.c
+3
-3
net/ipv4/igmp.c
···
213
213
/* It must be called with locked im->lock */
214
214
static void igmp_start_timer(struct ip_mc_list *im, int max_delay)
215
215
{
216
-
int tv = prandom_u32_max(max_delay);
216
+
int tv = get_random_u32_below(max_delay);
217
217
218
218
im->tm_running = 1;
219
219
if (!mod_timer(&im->timer, jiffies+tv+2))
···
222
222
223
223
static void igmp_gq_start_timer(struct in_device *in_dev)
224
224
{
225
-
int tv = prandom_u32_max(in_dev->mr_maxdelay);
225
+
int tv = get_random_u32_below(in_dev->mr_maxdelay);
226
226
unsigned long exp = jiffies + tv + 2;
227
227
228
228
if (in_dev->mr_gq_running &&
···
236
236
237
237
static void igmp_ifc_start_timer(struct in_device *in_dev, int delay)
238
238
{
239
-
int tv = prandom_u32_max(delay);
239
+
int tv = get_random_u32_below(delay);
240
240
241
241
if (!mod_timer(&in_dev->mr_ifc_timer, jiffies+tv+2))
242
242
in_dev_hold(in_dev);
+1
-1
net/ipv4/inet_connection_sock.c
+1
-1
net/ipv4/inet_connection_sock.c
···
314
314
if (likely(remaining > 1))
315
315
remaining &= ~1U;
316
316
317
-
offset = prandom_u32_max(remaining);
317
+
offset = get_random_u32_below(remaining);
318
318
/* __inet_hash_connect() favors ports having @low parity
319
319
* We do the opposite to not pollute connect() users.
320
320
*/
+1
-1
net/ipv4/inet_hashtables.c
+1
-1
net/ipv4/inet_hashtables.c
···
1037
1037
* on low contention the randomness is maximal and on high contention
1038
1038
* it may be inexistent.
1039
1039
*/
1040
-
i = max_t(int, i, prandom_u32_max(8) * 2);
1040
+
i = max_t(int, i, get_random_u32_below(8) * 2);
1041
1041
WRITE_ONCE(table_perturb[index], READ_ONCE(table_perturb[index]) + i + 2);
1042
1042
1043
1043
/* Head lock still held and bh's disabled */
+2
-2
net/ipv4/route.c
+2
-2
net/ipv4/route.c
···
471
471
old = READ_ONCE(*p_tstamp);
472
472
473
473
if (old != now && cmpxchg(p_tstamp, old, now) == old)
474
-
delta = prandom_u32_max(now - old);
474
+
delta = get_random_u32_below(now - old);
475
475
476
476
/* If UBSAN reports an error there, please make sure your compiler
477
477
* supports -fno-strict-overflow before reporting it that was a bug
···
689
689
} else {
690
690
/* Randomize max depth to avoid some side channels attacks. */
691
691
int max_depth = FNHE_RECLAIM_DEPTH +
692
-
prandom_u32_max(FNHE_RECLAIM_DEPTH);
692
+
get_random_u32_below(FNHE_RECLAIM_DEPTH);
693
693
694
694
while (depth > max_depth) {
695
695
fnhe_remove_oldest(hash);
+1
-1
net/ipv4/tcp_bbr.c
+1
-1
net/ipv4/tcp_bbr.c
···
618
618
struct bbr *bbr = inet_csk_ca(sk);
619
619
620
620
bbr->mode = BBR_PROBE_BW;
621
-
bbr->cycle_idx = CYCLE_LEN - 1 - prandom_u32_max(bbr_cycle_rand);
621
+
bbr->cycle_idx = CYCLE_LEN - 1 - get_random_u32_below(bbr_cycle_rand);
622
622
bbr_advance_cycle_phase(sk); /* flip to next phase of gain cycle */
623
623
}
624
624
+2
-1
net/ipv4/tcp_input.c
+2
-1
net/ipv4/tcp_input.c
···
3646
3646
u32 half = (ack_limit + 1) >> 1;
3647
3647
3648
3648
WRITE_ONCE(net->ipv4.tcp_challenge_timestamp, now);
3649
-
WRITE_ONCE(net->ipv4.tcp_challenge_count, half + prandom_u32_max(ack_limit));
3649
+
WRITE_ONCE(net->ipv4.tcp_challenge_count,
3650
+
half + get_random_u32_below(ack_limit));
3650
3651
}
3651
3652
count = READ_ONCE(net->ipv4.tcp_challenge_count);
3652
3653
if (count > 0) {
+4
-4
net/ipv6/addrconf.c
+4
-4
net/ipv6/addrconf.c
···
104
104
static inline s32 rfc3315_s14_backoff_init(s32 irt)
105
105
{
106
106
/* multiply 'initial retransmission time' by 0.9 .. 1.1 */
107
-
u64 tmp = (900000 + prandom_u32_max(200001)) * (u64)irt;
107
+
u64 tmp = (900000 + get_random_u32_below(200001)) * (u64)irt;
108
108
do_div(tmp, 1000000);
109
109
return (s32)tmp;
110
110
}
···
112
112
static inline s32 rfc3315_s14_backoff_update(s32 rt, s32 mrt)
113
113
{
114
114
/* multiply 'retransmission timeout' by 1.9 .. 2.1 */
115
-
u64 tmp = (1900000 + prandom_u32_max(200001)) * (u64)rt;
115
+
u64 tmp = (1900000 + get_random_u32_below(200001)) * (u64)rt;
116
116
do_div(tmp, 1000000);
117
117
if ((s32)tmp > mrt) {
118
118
/* multiply 'maximum retransmission time' by 0.9 .. 1.1 */
119
-
tmp = (900000 + prandom_u32_max(200001)) * (u64)mrt;
119
+
tmp = (900000 + get_random_u32_below(200001)) * (u64)mrt;
120
120
do_div(tmp, 1000000);
121
121
}
122
122
return (s32)tmp;
···
3967
3967
if (ifp->flags & IFA_F_OPTIMISTIC)
3968
3968
rand_num = 0;
3969
3969
else
3970
-
rand_num = prandom_u32_max(idev->cnf.rtr_solicit_delay ?: 1);
3970
+
rand_num = get_random_u32_below(idev->cnf.rtr_solicit_delay ? : 1);
3971
3971
3972
3972
nonce = 0;
3973
3973
if (idev->cnf.enhanced_dad ||
+5
-5
net/ipv6/mcast.c
+5
-5
net/ipv6/mcast.c
···
1050
1050
/* called with mc_lock */
1051
1051
static void mld_gq_start_work(struct inet6_dev *idev)
1052
1052
{
1053
-
unsigned long tv = prandom_u32_max(idev->mc_maxdelay);
1053
+
unsigned long tv = get_random_u32_below(idev->mc_maxdelay);
1054
1054
1055
1055
idev->mc_gq_running = 1;
1056
1056
if (!mod_delayed_work(mld_wq, &idev->mc_gq_work, tv + 2))
···
1068
1068
/* called with mc_lock */
1069
1069
static void mld_ifc_start_work(struct inet6_dev *idev, unsigned long delay)
1070
1070
{
1071
-
unsigned long tv = prandom_u32_max(delay);
1071
+
unsigned long tv = get_random_u32_below(delay);
1072
1072
1073
1073
if (!mod_delayed_work(mld_wq, &idev->mc_ifc_work, tv + 2))
1074
1074
in6_dev_hold(idev);
···
1085
1085
/* called with mc_lock */
1086
1086
static void mld_dad_start_work(struct inet6_dev *idev, unsigned long delay)
1087
1087
{
1088
-
unsigned long tv = prandom_u32_max(delay);
1088
+
unsigned long tv = get_random_u32_below(delay);
1089
1089
1090
1090
if (!mod_delayed_work(mld_wq, &idev->mc_dad_work, tv + 2))
1091
1091
in6_dev_hold(idev);
···
1130
1130
}
1131
1131
1132
1132
if (delay >= resptime)
1133
-
delay = prandom_u32_max(resptime);
1133
+
delay = get_random_u32_below(resptime);
1134
1134
1135
1135
if (!mod_delayed_work(mld_wq, &ma->mca_work, delay))
1136
1136
refcount_inc(&ma->mca_refcnt);
···
2574
2574
2575
2575
igmp6_send(&ma->mca_addr, ma->idev->dev, ICMPV6_MGM_REPORT);
2576
2576
2577
-
delay = prandom_u32_max(unsolicited_report_interval(ma->idev));
2577
+
delay = get_random_u32_below(unsolicited_report_interval(ma->idev));
2578
2578
2579
2579
if (cancel_delayed_work(&ma->mca_work)) {
2580
2580
refcount_dec(&ma->mca_refcnt);
+1
-1
net/ipv6/route.c
+1
-1
net/ipv6/route.c
···
1713
1713
net->ipv6.rt6_stats->fib_rt_cache++;
1714
1714
1715
1715
/* Randomize max depth to avoid some side channels attacks. */
1716
-
max_depth = FIB6_MAX_DEPTH + prandom_u32_max(FIB6_MAX_DEPTH);
1716
+
max_depth = FIB6_MAX_DEPTH + get_random_u32_below(FIB6_MAX_DEPTH);
1717
1717
while (bucket->depth > max_depth)
1718
1718
rt6_exception_remove_oldest(bucket);
1719
1719
+2
-2
net/netfilter/ipvs/ip_vs_twos.c
+2
-2
net/netfilter/ipvs/ip_vs_twos.c
···
71
71
* from 0 to total_weight
72
72
*/
73
73
total_weight += 1;
74
-
rweight1 = prandom_u32_max(total_weight);
75
-
rweight2 = prandom_u32_max(total_weight);
74
+
rweight1 = get_random_u32_below(total_weight);
75
+
rweight2 = get_random_u32_below(total_weight);
76
76
77
77
/* Pick two weighted servers */
78
78
list_for_each_entry_rcu(dest, &svc->destinations, n_list) {
+2
-2
net/netfilter/nf_conntrack_core.c
+2
-2
net/netfilter/nf_conntrack_core.c
···
906
906
nf_ct_zone_id(nf_ct_zone(ct), IP_CT_DIR_REPLY));
907
907
} while (nf_conntrack_double_lock(net, hash, reply_hash, sequence));
908
908
909
-
max_chainlen = MIN_CHAINLEN + prandom_u32_max(MAX_CHAINLEN);
909
+
max_chainlen = MIN_CHAINLEN + get_random_u32_below(MAX_CHAINLEN);
910
910
911
911
/* See if there's one in the list already, including reverse */
912
912
hlist_nulls_for_each_entry(h, n, &nf_conntrack_hash[hash], hnnode) {
···
1227
1227
goto dying;
1228
1228
}
1229
1229
1230
-
max_chainlen = MIN_CHAINLEN + prandom_u32_max(MAX_CHAINLEN);
1230
+
max_chainlen = MIN_CHAINLEN + get_random_u32_below(MAX_CHAINLEN);
1231
1231
/* See if there's one in the list already, including reverse:
1232
1232
NAT could have grabbed it without realizing, since we're
1233
1233
not in the hash. If there is, we lost race. */
+1
-1
net/netfilter/nf_nat_helper.c
+1
-1
net/netfilter/nf_nat_helper.c
+1
-1
net/netlink/af_netlink.c
+1
-1
net/netlink/af_netlink.c
···
835
835
/* Bind collision, search negative portid values. */
836
836
if (rover == -4096)
837
837
/* rover will be in range [S32_MIN, -4097] */
838
-
rover = S32_MIN + prandom_u32_max(-4096 - S32_MIN);
838
+
rover = S32_MIN + get_random_u32_below(-4096 - S32_MIN);
839
839
else if (rover >= -4096)
840
840
rover = -4097;
841
841
portid = rover--;
+2
-2
net/packet/af_packet.c
+2
-2
net/packet/af_packet.c
···
1350
1350
if (READ_ONCE(history[i]) == rxhash)
1351
1351
count++;
1352
1352
1353
-
victim = prandom_u32_max(ROLLOVER_HLEN);
1353
+
victim = get_random_u32_below(ROLLOVER_HLEN);
1354
1354
1355
1355
/* Avoid dirtying the cache line if possible */
1356
1356
if (READ_ONCE(history[victim]) != rxhash)
···
1386
1386
struct sk_buff *skb,
1387
1387
unsigned int num)
1388
1388
{
1389
-
return prandom_u32_max(num);
1389
+
return get_random_u32_below(num);
1390
1390
}
1391
1391
1392
1392
static unsigned int fanout_demux_rollover(struct packet_fanout *f,
+1
-1
net/sched/act_gact.c
+1
-1
net/sched/act_gact.c
+1
-1
net/sched/act_sample.c
+1
-1
net/sched/act_sample.c
···
168
168
psample_group = rcu_dereference_bh(s->psample_group);
169
169
170
170
/* randomly sample packets according to rate */
171
-
if (psample_group && (prandom_u32_max(s->rate) == 0)) {
171
+
if (psample_group && (get_random_u32_below(s->rate) == 0)) {
172
172
if (!skb_at_tc_ingress(skb)) {
173
173
md.in_ifindex = skb->skb_iif;
174
174
md.out_ifindex = skb->dev->ifindex;
+1
-1
net/sched/sch_choke.c
+1
-1
net/sched/sch_choke.c
+2
-2
net/sched/sch_netem.c
+2
-2
net/sched/sch_netem.c
+1
-1
net/sctp/socket.c
+1
-1
net/sctp/socket.c
+1
-1
net/sctp/transport.c
+1
-1
net/sctp/transport.c
···
199
199
if ((time_before(transport->hb_timer.expires, expires) ||
200
200
!timer_pending(&transport->hb_timer)) &&
201
201
!mod_timer(&transport->hb_timer,
202
-
expires + prandom_u32_max(transport->rto)))
202
+
expires + get_random_u32_below(transport->rto)))
203
203
sctp_transport_hold(transport);
204
204
}
205
205
+1
-1
net/sunrpc/cache.c
+1
-1
net/sunrpc/cache.c
+1
-1
net/sunrpc/xprtsock.c
+1
-1
net/sunrpc/xprtsock.c
+1
-1
net/tipc/socket.c
+1
-1
net/tipc/socket.c
···
3010
3010
struct net *net = sock_net(sk);
3011
3011
struct tipc_net *tn = net_generic(net, tipc_net_id);
3012
3012
u32 remaining = (TIPC_MAX_PORT - TIPC_MIN_PORT) + 1;
3013
-
u32 portid = prandom_u32_max(remaining) + TIPC_MIN_PORT;
3013
+
u32 portid = get_random_u32_below(remaining) + TIPC_MIN_PORT;
3014
3014
3015
3015
while (remaining--) {
3016
3016
portid++;
+1
-1
net/vmw_vsock/af_vsock.c
+1
-1
net/vmw_vsock/af_vsock.c
+1
-1
net/xfrm/xfrm_state.c
+1
-1
net/xfrm/xfrm_state.c
···
2072
2072
} else {
2073
2073
u32 spi = 0;
2074
2074
for (h = 0; h < high-low+1; h++) {
2075
-
spi = low + prandom_u32_max(high - low + 1);
2075
+
spi = low + get_random_u32_below(high - low + 1);
2076
2076
x0 = xfrm_state_lookup(net, mark, &x->id.daddr, htonl(spi), x->id.proto, x->props.family);
2077
2077
if (x0 == NULL) {
2078
2078
newspi = htonl(spi);