arch/arc/kernel/setup.c

622

return *pos < nr_cpu_ids ? cpu_to_ptr(*pos) : NULL;

arch/arm/include/asm/smp_plat.h

83

for (cpu = 0; cpu < nr_cpu_ids; cpu++)

arch/arm/kernel/devtree.c

129

if (WARN(cpuidx > nr_cpu_ids, "DT /cpu %u nodes greater than "

arch/arm/kernel/devtree.c

131

cpuidx, nr_cpu_ids)) {

arch/arm/kernel/devtree.c

132

cpuidx = nr_cpu_ids;

arch/arm/kernel/setup.c

603

for (i = 1; i < nr_cpu_ids; ++i)

arch/arm/kernel/topology.c

94

__cpu_capacity = kcalloc(nr_cpu_ids, sizeof(*__cpu_capacity),

arch/arm/mach-bcm/bcm63xx_smp.c

64

if (ncores > nr_cpu_ids) {

arch/arm/mach-bcm/bcm63xx_smp.c

66

ncores, nr_cpu_ids);

arch/arm/mach-bcm/bcm63xx_smp.c

67

ncores = nr_cpu_ids;

arch/arm/mach-imx/mmdc.c

226

if (target >= nr_cpu_ids)

arch/arm/mach-omap2/omap-smp.c

278

if (ncores > nr_cpu_ids) {

arch/arm/mach-omap2/omap-smp.c

280

ncores, nr_cpu_ids);

arch/arm/mach-omap2/omap-smp.c

281

ncores = nr_cpu_ids;

arch/arm/mach-spear/platsmp.c

102

if (ncores > nr_cpu_ids) {

arch/arm/mach-spear/platsmp.c

104

ncores, nr_cpu_ids);

arch/arm/mach-spear/platsmp.c

105

ncores = nr_cpu_ids;

arch/arm/mm/cache-l2x0-pmu.c

432

if (target >= nr_cpu_ids)

arch/arm64/include/asm/smp_plat.h

38

for (cpu = 0; cpu < nr_cpu_ids; cpu++)

arch/arm64/kernel/acpi.c

468

if (cpu >= nr_cpu_ids)

arch/arm64/kernel/acpi.c

485

for (int cpu = 0; cpu < nr_cpu_ids; cpu++) {

arch/arm64/kernel/cpufeature.c

2091

return nr_cpu_ids;

arch/arm64/kernel/cpufeature.c

3983

if (caps->cpus && cpumask_any(caps->cpus) < nr_cpu_ids)

arch/arm64/kernel/cpuinfo.c

290

return *pos < nr_cpu_ids ? &per_cpu(cpu_data, *pos) : NULL;

arch/arm64/kernel/smp.c

664

for (i = 0; i < nr_cpu_ids; i++)

arch/arm64/kernel/smp.c

759

if (cpu_count > nr_cpu_ids)

arch/arm64/kernel/smp.c

761

cpu_count, nr_cpu_ids);

arch/arm64/kernel/smp.c

769

for (i = 1; i < nr_cpu_ids; i++) {

arch/arm64/kernel/topology.c

224

ref_cpu = nr_cpu_ids;

arch/arm64/kernel/topology.c

233

if (ref_cpu >= nr_cpu_ids)

arch/arm64/kernel/topology.c

444

if ((cpu >= nr_cpu_ids) || !cpumask_test_cpu(cpu, cpu_present_mask))

arch/arm64/kernel/topology.c

67

if ((cpu >= nr_cpu_ids) || !cpumask_test_cpu(cpu, cpu_present_mask))

arch/hexagon/kernel/setup.c

97

return *pos < nr_cpu_ids ? (void *)((unsigned long) *pos + 1) : NULL;

arch/loongarch/kernel/acpi.c

411

if (cpu < 0 || cpu >= nr_cpu_ids) {

arch/loongarch/kernel/acpi.c

444

if (cpu >= nr_cpu_ids)

arch/loongarch/kernel/irq.c

98

irq_set_nr_irqs(64 + NR_VECTORS * (nr_cpu_ids + nr_io_pics));

arch/loongarch/kernel/proc.c

114

return i < nr_cpu_ids ? (void *)(i + 1) : NULL;

arch/loongarch/kernel/setup.c

577

if (possible > nr_cpu_ids)

arch/loongarch/kernel/setup.c

578

possible = nr_cpu_ids;

arch/loongarch/kernel/smp.c

327

if (cpuid >= nr_cpu_ids)

arch/mips/cavium-octeon/octeon-irq.c

2531

if (cpu >= nr_cpu_ids)

arch/mips/cavium-octeon/octeon-irq.c

284

if (cpu >= nr_cpu_ids) {

arch/mips/include/asm/mips-cps.h

255

last_cl = cpu_cluster(&cpu_data[nr_cpu_ids - 1]);

arch/mips/kernel/mips-cm.c

556

return (*first_cpu >= nr_cpu_ids);

arch/mips/kernel/proc.c

312

return i < nr_cpu_ids ? (void *) (i + 1) : NULL;

arch/mips/kernel/setup.c

732

if (possible > nr_cpu_ids)

arch/mips/kernel/setup.c

733

possible = nr_cpu_ids;

arch/mips/lantiq/irq.c

144

if (unlikely(vpe >= nr_cpu_ids))

arch/mips/sgi-ip27/ip27-irq.c

78

if (cpu >= nr_cpu_ids)

arch/openrisc/kernel/setup.c

320

if ((*pos) < nr_cpu_ids)

arch/openrisc/kernel/smp.c

255

if (cpumask_any_but(cmask, cpuid) >= nr_cpu_ids) {

arch/openrisc/kernel/smp.c

293

if (cpumask_any_but(cmask, cpuid) >= nr_cpu_ids) {

arch/parisc/kernel/irq.c

106

if (cpu_dest >= nr_cpu_ids)

arch/parisc/kernel/irq.c

329

while ((next_cpu < nr_cpu_ids) &&

arch/parisc/kernel/irq.c

334

if (next_cpu >= nr_cpu_ids)

arch/parisc/kernel/processor.c

89

if (num_online_cpus() >= nr_cpu_ids) {

arch/parisc/kernel/smp.c

437

if (num_online_cpus() < nr_cpu_ids &&

arch/powerpc/include/asm/cputhreads.h

37

return nr_cpu_ids >> threads_shift;

arch/powerpc/kernel/irq.c

379

if (cpuid >= nr_cpu_ids)

arch/powerpc/kernel/paca.c

245

paca_nr_cpu_ids = nr_cpu_ids;

arch/powerpc/kernel/paca.c

247

paca_ptrs_size = sizeof(struct paca_struct *) * nr_cpu_ids;

arch/powerpc/kernel/paca.c

291

new_ptrs_size = sizeof(struct paca_struct *) * nr_cpu_ids;

arch/powerpc/kernel/paca.c

296

paca_nr_cpu_ids = nr_cpu_ids;

arch/powerpc/kernel/paca.c

309

paca_ptrs_size + paca_struct_size, nr_cpu_ids);

arch/powerpc/kernel/paca.c

62

size_t shared_lppaca_total_size = PAGE_ALIGN(nr_cpu_ids * LPPACA_SIZE);

arch/powerpc/kernel/prom.c

381

if (nr_cpu_ids % nthreads != 0) {

arch/powerpc/kernel/prom.c

382

set_nr_cpu_ids(ALIGN(nr_cpu_ids, nthreads));

arch/powerpc/kernel/prom.c

384

nr_cpu_ids);

arch/powerpc/kernel/prom.c

387

if (boot_cpuid >= nr_cpu_ids) {

arch/powerpc/kernel/rtasd.c

438

if (cpu >= nr_cpu_ids) {

arch/powerpc/kernel/setup-common.c

336

if ((*pos) < nr_cpu_ids)

arch/powerpc/kernel/setup-common.c

417

for (int i = 0; i < nthreads && cpu < nr_cpu_ids; i++) {

arch/powerpc/kernel/setup-common.c

459

cpu_to_phys_id = memblock_alloc_or_panic(nr_cpu_ids * sizeof(u32),

arch/powerpc/kernel/setup-common.c

505

} else if (cpu >= nr_cpu_ids) {

arch/powerpc/kernel/setup-common.c

510

if (cpu < nr_cpu_ids)

arch/powerpc/kernel/setup-common.c

544

if (maxcpus > nr_cpu_ids) {

arch/powerpc/kernel/setup-common.c

548

maxcpus, nr_cpu_ids);

arch/powerpc/kernel/setup-common.c

549

maxcpus = nr_cpu_ids;

arch/powerpc/kernel/setup-common.c

907

memblock_free(cpu_to_phys_id, nr_cpu_ids * sizeof(u32));

arch/powerpc/kernel/smp.c

168

if (nr < 0 || nr >= nr_cpu_ids)

arch/powerpc/kexec/crash.c

253

for (i=0; i < nr_cpu_ids && msecs > 0; i++) {

arch/powerpc/kvm/book3s_hv.c

213

if (cpu >= 0 && cpu < nr_cpu_ids) {

arch/powerpc/kvm/book3s_hv.c

248

if (cpu >= 0 && cpu < nr_cpu_ids && cpu_online(cpu))

arch/powerpc/kvm/book3s_hv.c

5653

for (cpu = 0; cpu < nr_cpu_ids; cpu += threads_per_core) {

arch/powerpc/kvm/book3s_hv_rm_xics.c

150

if (cpu < 0 || cpu >= nr_cpu_ids) {

arch/powerpc/mm/numa.c

1073

for (cpu = 0; cpu < nr_cpu_ids; cpu++) {

arch/powerpc/mm/numa.c

1087

pr_cont("-%u", nr_cpu_ids - 1);

arch/powerpc/mm/numa.c

1439

if (cpu < 0 || cpu > nr_cpu_ids)

arch/powerpc/perf/hv-24x7.c

1668

if (target < 0 || target >= nr_cpu_ids) {

arch/powerpc/perf/hv-gpci.c

873

if (target < 0 || target >= nr_cpu_ids) {

arch/powerpc/perf/imc-pmu.c

402

if (target >= 0 && target < nr_cpu_ids) {

arch/powerpc/perf/imc-pmu.c

704

if (ncpu >= 0 && ncpu < nr_cpu_ids) {

arch/powerpc/platforms/powernv/opal-imc.c

191

if (cpu >= nr_cpu_ids)

arch/powerpc/platforms/powernv/smp.c

73

if (nr < 0 || nr >= nr_cpu_ids)

arch/powerpc/platforms/pseries/hotplug-cpu.c

321

if (cpu >= nr_cpu_ids)

arch/powerpc/platforms/pseries/smp.c

144

if (nr < 0 || nr >= nr_cpu_ids)

arch/powerpc/sysdev/xics/xics-common.c

288

if (server < nr_cpu_ids)

arch/powerpc/sysdev/xive/common.c

556

WARN_ON(first >= nr_cpu_ids);

arch/powerpc/sysdev/xive/common.c

634

target >= nr_cpu_ids))

arch/powerpc/sysdev/xive/common.c

731

if (WARN_ON(target >= nr_cpu_ids))

arch/powerpc/sysdev/xive/native.c

538

pr_debug("Allocating VP block for pool size %u\n", nr_cpu_ids);

arch/powerpc/sysdev/xive/native.c

540

xive_pool_vps = xive_native_alloc_vp_block(nr_cpu_ids);

arch/powerpc/sysdev/xive/native.c

545

xive_pool_vps, nr_cpu_ids);

arch/riscv/kernel/acpi.c

345

if (cpu >= nr_cpu_ids)

arch/riscv/kernel/acpi_numa.c

103

for (i = 0; i < nr_cpu_ids; i++)

arch/riscv/kernel/acpi_numa.c

43

for (int cpu = 0; cpu < nr_cpu_ids; cpu++) {

arch/riscv/kernel/cpu.c

310

if (*pos == nr_cpu_ids)

arch/riscv/kernel/cpu.c

314

if ((*pos) < nr_cpu_ids)

arch/riscv/kernel/smpboot.c

155

if (cpuid > nr_cpu_ids)

arch/riscv/kernel/smpboot.c

157

cpuid, nr_cpu_ids);

arch/riscv/kernel/smpboot.c

171

for (cpuid = 1; cpuid < nr_cpu_ids; cpuid++)

arch/riscv/mm/tlbflush.c

132

if (cpumask_any_but(cmask, cpu) >= nr_cpu_ids) {

arch/s390/kernel/perf_cpum_cf.c

1471

bytes = sizeof(((struct s390_ctrset_read *)0)->no_cpus) + nr_cpu_ids *

arch/s390/kernel/processor.c

361

return *pos < nr_cpu_ids ? (void *)*pos + 1 : NULL;

arch/s390/kernel/processor.c

77

if (cpu >= nr_cpu_ids)

arch/s390/kernel/smp.c

1037

if (cpu + i >= nr_cpu_ids || !cpu_present(cpu + i))

arch/s390/kernel/smp.c

1052

if (cpu + i >= nr_cpu_ids || !cpu_present(cpu + i))

arch/s390/kernel/smp.c

677

for (i = cpu; (i <= cpu + smp_cpu_mtid) && (i < nr_cpu_ids); i++)

arch/s390/kernel/smp.c

720

for (i = 0; (i <= smp_cpu_mtid) && (cpu < nr_cpu_ids); i++) {

arch/s390/kernel/smp.c

943

sclp_max = (sclp.max_cores * sclp_max) ?: nr_cpu_ids;

arch/s390/kernel/smp.c

944

possible = setup_possible_cpus ?: nr_cpu_ids;

arch/s390/kernel/smp.c

946

for (cpu = 0; cpu < possible && cpu < nr_cpu_ids; cpu++)

arch/s390/kernel/topology.c

110

max_cpu = min(cpu + smp_cpu_mtid, nr_cpu_ids - 1);

arch/s390/kernel/topology.c

137

max_cpu = min(cpu + smp_cpu_mtid, nr_cpu_ids - 1);

arch/sh/kernel/cpu/proc.c

135

return *pos < nr_cpu_ids ? cpu_data + *pos : NULL;

arch/sh/kernel/irq.c

238

if (newcpu >= nr_cpu_ids) {

arch/sparc/kernel/ds.c

659

if (cpu_list[i] < nr_cpu_ids)

arch/sparc/kernel/irq_64.c

357

cpuid = cpuid < nr_cpu_ids ? cpuid : map_to_cpu(irq);

arch/sparc/kernel/leon_kernel.c

111

if (cpumask_subset(cpu_online_mask, affinity) || cpu >= nr_cpu_ids)

arch/sparc/kernel/nmi.c

175

prev_nmi_count = kmalloc_array(nr_cpu_ids, sizeof(unsigned int),

arch/sparc/kernel/prom_64.c

489

if (num_possible_cpus() < nr_cpu_ids)

arch/sparc/mm/init_64.c

1323

if (*id < nr_cpu_ids)

arch/sparc/mm/srmmu.c

1021

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

arch/sparc/mm/srmmu.c

1618

return cpumask_any_but(mm_cpumask(mm), smp_processor_id()) < nr_cpu_ids;

arch/um/kernel/um_arch.c

102

if (*pos < nr_cpu_ids)

arch/x86/events/intel/core.c

7495

return (cpu >= nr_cpu_ids) ? -1 : cpu;

arch/x86/events/intel/uncore.c

1547

if (target < nr_cpu_ids)

arch/x86/events/intel/uncore.c

1642

if (target < nr_cpu_ids)

arch/x86/hyperv/hv_init.c

318

if (new_cpu < nr_cpu_ids)

arch/x86/hyperv/hv_init.c

470

hv_vp_assist_page = kzalloc_objs(*hv_vp_assist_page, nr_cpu_ids);

arch/x86/include/asm/tlbflush.h

353

if (cpumask_any_but(mm_cpumask(mm), get_cpu()) < nr_cpu_ids)

arch/x86/kernel/acpi/boot.c

1856

if (cpu >= nr_cpu_ids)

arch/x86/kernel/apic/apic_common.c

24

if (mps_cpu < nr_cpu_ids && cpu_present(mps_cpu))

arch/x86/kernel/apic/vector.c

721

if (irq_get_nr_irqs() > NR_VECTORS * nr_cpu_ids)

arch/x86/kernel/apic/vector.c

722

irq_set_nr_irqs(NR_VECTORS * nr_cpu_ids);

arch/x86/kernel/apic/vector.c

724

nr = (gsi_top + nr_legacy_irqs()) + 8 * nr_cpu_ids;

arch/x86/kernel/apic/vector.c

730

nr += 8 * nr_cpu_ids;

arch/x86/kernel/apic/x2apic_cluster.c

211

slots = max_t(u32, L1_CACHE_BYTES/sizeof(u32), nr_cpu_ids);

arch/x86/kernel/cpu/mce/inject.c

407

if (val >= nr_cpu_ids || !cpu_online(val)) {

arch/x86/kernel/cpu/proc.c

162

if ((*pos) < nr_cpu_ids)

arch/x86/kernel/cpu/topology.c

267

if (apic_id != topo_info.boot_cpu_apic_id && topo_info.nr_assigned_cpus >= nr_cpu_ids) {

arch/x86/kernel/cpu/topology.c

268

pr_warn_once("CPU limit of %d reached. Ignoring further CPUs\n", nr_cpu_ids);

arch/x86/kernel/cpu/topology.c

421

unsigned int possible = nr_cpu_ids;

arch/x86/kernel/cpu/topology.c

430

if (possible < nr_cpu_ids) {

arch/x86/kernel/cpu/topology.c

472

if (WARN_ON_ONCE(assigned > nr_cpu_ids)) {

arch/x86/kernel/cpu/topology.c

473

disabled += assigned - nr_cpu_ids;

arch/x86/kernel/cpu/topology.c

474

assigned = nr_cpu_ids;

arch/x86/kernel/cpu/topology.c

476

allowed = min_t(unsigned int, total, nr_cpu_ids);

arch/x86/kernel/cpuid.c

106

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

arch/x86/kernel/hw_breakpoint.c

279

sizeof(unsigned long) * nr_cpu_ids))

arch/x86/kernel/msr.c

214

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

arch/x86/kernel/setup_percpu.c

118

NR_CPUS, nr_cpumask_bits, nr_cpu_ids, nr_node_ids);

arch/x86/kernel/smpboot.c

1182

per_cpu(cpu_info.cpu_index, cpu) = nr_cpu_ids;

arch/x86/kernel/tsc.c

1592

if (sibling < nr_cpu_ids)

arch/x86/kernel/tsc_sync.c

103

if (next_cpu >= nr_cpu_ids)

arch/x86/kernel/tsc_sync.c

209

refcpu = mask ? cpumask_any_but(mask, cpu) : nr_cpu_ids;

arch/x86/kernel/tsc_sync.c

211

if (refcpu >= nr_cpu_ids) {

arch/x86/mm/numa.c

166

for (i = 0; i < nr_cpu_ids; i++) {

arch/x86/mm/numa.c

190

for (i = 0; i < nr_cpu_ids; i++) {

arch/x86/mm/numa.c

87

if (cpu >= nr_cpu_ids || !cpu_possible(cpu)) {

arch/x86/mm/tlb.c

1449

} else if (cpumask_any_but(mm_cpumask(mm), cpu) < nr_cpu_ids) {

arch/x86/mm/tlb.c

1724

} else if (cpumask_any_but(&batch->cpumask, cpu) < nr_cpu_ids) {

arch/x86/xen/smp_pv.c

155

for (i = 0; i < nr_cpu_ids; i++)

arch/x86/xen/smp_pv.c

214

for (cpu = nr_cpu_ids - 1; !cpu_possible(cpu); cpu--)

arch/x86/xen/smp_pv.c

412

for (cpus = 0; cpus < nr_cpu_ids; cpus++) {

arch/x86/xen/smp_pv.c

418

if (cpus < nr_cpu_ids)

arch/xtensa/kernel/irq.c

185

if (newcpu >= nr_cpu_ids) {

block/blk-mq.c

2217

if (cpu >= nr_cpu_ids)

block/blk-mq.c

2228

return hctx->next_cpu >= nr_cpu_ids;

block/blk-mq.c

2250

if (next_cpu >= nr_cpu_ids)

block/blk-mq.c

4050

hctx->ctxs = kmalloc_array_node(nr_cpu_ids, sizeof(void *),

block/blk-mq.c

4055

if (sbitmap_init_node(&hctx->ctx_map, nr_cpu_ids, ilog2(8),

block/blk-mq.c

4876

if (set->nr_maps == 1 && set->nr_hw_queues > nr_cpu_ids)

block/blk-mq.c

4877

set->nr_hw_queues = nr_cpu_ids;

block/blk-mq.c

4901

set->map[i].mq_map = kcalloc_node(nr_cpu_ids,

block/blk-mq.c

5119

if (set->nr_maps == 1 && nr_hw_queues > nr_cpu_ids)

block/blk-mq.c

5120

nr_hw_queues = nr_cpu_ids;

block/blk-mq.c

750

if (cpu >= nr_cpu_ids)

drivers/acpi/acpi_processor.c

202

BUG_ON(pr->id >= nr_cpu_ids);

drivers/acpi/acpi_processor.c

484

if (pr->id >= nr_cpu_ids)

drivers/acpi/processor_core.c

309

if (nr_cpu_ids <= 1 && acpi_id == 0)

drivers/base/cacheinfo.c

696

return sysfs_emit(buf, "%*pb\n", nr_cpu_ids, mask);

drivers/base/cacheinfo.c

705

return sysfs_emit(buf, "%*pbl\n", nr_cpu_ids, mask);

drivers/base/cpu.c

261

if (total_cpus && nr_cpu_ids < total_cpus) {

drivers/base/cpu.c

264

if (nr_cpu_ids == total_cpus-1)

drivers/base/cpu.c

265

len += sysfs_emit_at(buf, len, "%u", nr_cpu_ids);

drivers/base/cpu.c

268

nr_cpu_ids, total_cpus - 1);

drivers/base/cpu.c

448

if (cpu < nr_cpu_ids && cpu_possible(cpu))

drivers/block/drbd/drbd_main.c

2471

if (nr_cpu_ids > 1 && res_opts->cpu_mask[0] != 0) {

drivers/block/drbd/drbd_main.c

2473

cpumask_bits(new_cpu_mask), nr_cpu_ids);

drivers/block/drbd/drbd_main.c

2483

nr_cpu_ids);

drivers/block/drbd/drbd_main.c

476

resources_per_cpu = kcalloc(nr_cpu_ids, sizeof(*resources_per_cpu),

drivers/block/null_blk/main.c

1816

int nqueues = nr_cpu_ids;

drivers/block/null_blk/main.c

1899

} else if (dev->submit_queues > nr_cpu_ids)

drivers/block/null_blk/main.c

1900

dev->submit_queues = nr_cpu_ids;

drivers/block/null_blk/main.c

2156

} else if (g_submit_queues > nr_cpu_ids) {

drivers/block/null_blk/main.c

2157

g_submit_queues = nr_cpu_ids;

drivers/block/null_blk/main.c

395

if (submit_queues > nr_cpu_ids || poll_queues > g_poll_queues)

drivers/block/rnbd/rnbd-clt-sysfs.c

190

nr_poll_queues > (int)nr_cpu_ids) {

drivers/block/rnbd/rnbd-clt-sysfs.c

197

nr_poll_queues = nr_cpu_ids;

drivers/block/rnbd/rnbd-clt.c

1421

nr_cpu_ids + nr_poll_queues);

drivers/block/rnbd/rnbd-clt.c

168

bit = find_next_bit(sess->cpu_queues_bm, nr_cpu_ids, cpu);

drivers/block/rnbd/rnbd-clt.c

169

if (bit < nr_cpu_ids) {

drivers/block/rnbd/rnbd-clt.c

183

return (cpu + 1) % nr_cpu_ids;

drivers/block/ublk_drv.c

4607

if (header->len * BITS_PER_BYTE < nr_cpu_ids)

drivers/block/ublk_drv.c

4816

ub->dev_info.nr_hw_queues, nr_cpu_ids);

drivers/bus/arm-cci.c

269

for (cpu = 0; cpu < nr_cpu_ids; cpu++) {

drivers/char/random.c

1328

if (cpu >= nr_cpu_ids)

drivers/cpufreq/cpufreq.c

210

if (WARN_ON(cpu >= nr_cpu_ids))

drivers/cpufreq/speedstep-centrino.c

450

if (good_cpu >= nr_cpu_ids) {

drivers/cpuidle/coupled.c

443

&cpuidle_coupled_poke_pending) < nr_cpu_ids;

drivers/devfreq/event/rockchip-dfi.c

604

if (target >= nr_cpu_ids)

drivers/edac/imh_base.c

125

if (cpu >= nr_cpu_ids)

drivers/firmware/arm_ffa/driver.c

844

u16 vcpu_count = nr_cpu_ids;

drivers/fpga/dfl-fme-perf.c

952

if (target >= nr_cpu_ids)

drivers/gpu/drm/amd/amdkfd/kfd_topology.c

2350

if (first_cpu_of_numa_node >= nr_cpu_ids)

drivers/hv/hv.c

559

start = get_random_u32_below(nr_cpu_ids);

drivers/hv/hv_common.c

387

hv_vp_index = kmalloc_array(nr_cpu_ids, sizeof(*hv_vp_index),

drivers/hv/hv_common.c

394

for (i = 0; i < nr_cpu_ids; i++)

drivers/hv/mshv_debugfs.c

514

parent_vp_stats = kzalloc_objs(*parent_vp_stats, nr_cpu_ids);

drivers/hv/mshv_vtl_main.c

805

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

drivers/hwmon/coretemp.c

743

if (target >= nr_cpu_ids) {

drivers/hwtracing/coresight/coresight-etm-perf.c

493

if (cpu >= nr_cpu_ids)

drivers/hwtracing/coresight/coresight-platform.c

779

if (cpu >= nr_cpu_ids)

drivers/hwtracing/ptt/hisi_ptt.c

1397

if (target >= nr_cpu_ids) {

drivers/infiniband/core/uverbs_std_types_dmah.c

50

if (dmah->cpu_id >= nr_cpu_ids) {

drivers/infiniband/hw/hfi1/affinity.c

1138

if (cpu >= nr_cpu_ids) /* empty */

drivers/infiniband/hw/hfi1/affinity.c

114

cpumask_clear_cpus(&node_affinity.real_cpu_mask, curr_cpu, nr_cpu_ids - curr_cpu);

drivers/infiniband/hw/hfi1/affinity.c

253

if (ret_cpu >= nr_cpu_ids) {

drivers/infiniband/hw/hfi1/affinity.c

289

if (max_cpu >= nr_cpu_ids)

drivers/infiniband/hw/hfi1/affinity.c

343

if (cpu >= nr_cpu_ids)

drivers/infiniband/hw/hfi1/affinity.c

346

if (cpu >= nr_cpu_ids) { /* empty */

drivers/infiniband/hw/hfi1/affinity.c

590

if (cpumask_first(local_mask) >= nr_cpu_ids)

drivers/infiniband/hw/hfi1/affinity.c

651

if (curr_cpu >= nr_cpu_ids)

drivers/infiniband/hw/hfi1/affinity.c

75

if (cpu >= nr_cpu_ids) /* empty */

drivers/infiniband/hw/hfi1/affinity.c

970

cpumask_clear_cpus(hw_thread_mask, curr_cpu, nr_cpu_ids - curr_cpu);

drivers/infiniband/ulp/rtrs/rtrs-clt.c

1621

con->cpu = (cid ? cid - 1 : 0) % nr_cpu_ids;

drivers/infiniband/ulp/rtrs/rtrs-clt.c

2845

clt_path = alloc_path(clt, &paths[i], nr_cpu_ids,

drivers/infiniband/ulp/rtrs/rtrs-clt.c

3124

clt_path = alloc_path(clt, addr, nr_cpu_ids, 0);

drivers/infiniband/ulp/rtrs/rtrs-srv.c

1386

if (v >= nr_cpu_ids || v >= ib_dev->num_comp_vectors)

drivers/iommu/hyperv/hv-irq-remap-x86.c

165

for (i = min_t(unsigned int, nr_cpu_ids - 1, 255); i >= 0; i--)

drivers/iommu/intel/irq_remapping.c

1127

if (WARN_ON(cpu >= nr_cpu_ids))

drivers/irqchip/irq-armada-370-xp.c

255

if (cpu >= nr_cpu_ids)

drivers/irqchip/irq-bcm6345-l1.c

199

if (new_cpu >= nr_cpu_ids)

drivers/irqchip/irq-csky-mpintc.c

139

if (cpu >= nr_cpu_ids)

drivers/irqchip/irq-csky-mpintc.c

249

INTCL_SIZE*nr_cpu_ids + INTCG_SIZE);

drivers/irqchip/irq-gic-v3-its.c

1677

unsigned int cpu = nr_cpu_ids, tmp;

drivers/irqchip/irq-gic-v3-its.c

1732

if (cpu < nr_cpu_ids)

drivers/irqchip/irq-gic-v3-its.c

1787

if (cpu < 0 || cpu >= nr_cpu_ids)

drivers/irqchip/irq-gic-v3-its.c

3028

its->collections = kzalloc_objs(*its->collections, nr_cpu_ids);

drivers/irqchip/irq-gic-v3-its.c

3032

for (i = 0; i < nr_cpu_ids; i++)

drivers/irqchip/irq-gic-v3-its.c

3728

if (cpu < 0 || cpu >= nr_cpu_ids)

drivers/irqchip/irq-gic-v3-its.c

3912

unsigned int from, cpu = nr_cpu_ids;

drivers/irqchip/irq-gic-v3-its.c

3963

if (cpu < nr_cpu_ids) {

drivers/irqchip/irq-gic-v3-its.c

5168

entries = roundup_pow_of_two(nr_cpu_ids);

drivers/irqchip/irq-gic-v3.c

1340

while (cpu < nr_cpu_ids) {

drivers/irqchip/irq-gic-v3.c

1344

if (next_cpu >= nr_cpu_ids)

drivers/irqchip/irq-gic-v3.c

1442

if (cpu >= nr_cpu_ids)

drivers/irqchip/irq-gic-v5.c

1019

unsigned int num_ipis = GICV5_IPIS_PER_CPU * nr_cpu_ids;

drivers/irqchip/irq-gic-v5.c

1030

set_smp_ipi_range_percpu(base_ipi_virq, GICV5_IPIS_PER_CPU, nr_cpu_ids);

drivers/irqchip/irq-gic-v5.c

1075

0, GICV5_IPIS_PER_CPU * nr_cpu_ids,

drivers/irqchip/irq-gic.c

808

if (cpu >= NR_GIC_CPU_IF || cpu >= nr_cpu_ids)

drivers/irqchip/irq-gic.c

825

if (unlikely(nr_cpu_ids == 1)) {

drivers/irqchip/irq-hip04.c

159

if (cpu >= NR_HIP04_CPU_IF || cpu >= nr_cpu_ids)

drivers/irqchip/irq-loongson-eiointc.c

155

if (cpu >= nr_cpu_ids) {

drivers/irqchip/irq-mips-gic.c

110

(cpu) < nr_cpu_ids; \

drivers/irqchip/irq-mips-gic.c

77

if (cpu >= nr_cpu_ids)

drivers/irqchip/irq-riscv-aplic-direct.c

66

if (cpu >= nr_cpu_ids)

drivers/irqchip/irq-sifive-plic.c

202

if (cpu >= nr_cpu_ids)

drivers/md/dm-ps-io-affinity.c

119

s->path_map = kzalloc_objs(struct path_info *, nr_cpu_ids);

drivers/md/dm-ps-io-affinity.c

80

if (cpu >= nr_cpu_ids) {

drivers/md/dm-ps-io-affinity.c

82

cpu, nr_cpu_ids);

drivers/misc/lkdtm/bugs.c

356

if (target >= nr_cpu_ids) {

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

3327

if (rx_cpu >= nr_cpu_ids)

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c

3333

if (txc_cpu >= nr_cpu_ids)

drivers/net/ethernet/google/gve/gve_main.c

578

if (cur_cpu >= nr_cpu_ids || (i + 1) == priv->tx_cfg.max_queues)

drivers/net/ethernet/intel/idpf/idpf_txrx.h

989

return cpu < nr_cpu_ids ? cpu_to_mem(cpu) : NUMA_NO_NODE;

drivers/net/ethernet/intel/ixgbe/ixgbe_lib.c

305

queues = min_t(int, IXGBE_MAX_XDP_QS, nr_cpu_ids);

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

10942

if (nr_cpu_ids > IXGBE_MAX_XDP_QS * 2)

drivers/net/ethernet/intel/ixgbe/ixgbe_main.c

7071

if (nr_cpu_ids > IXGBE_MAX_XDP_QS)

drivers/net/ethernet/intel/libeth/xsk.c

231

if (unlikely(qid >= nr_cpu_ids))

drivers/net/ethernet/intel/libeth/xsk.c

232

qid %= nr_cpu_ids;

drivers/net/ethernet/marvell/mvneta.c

4385

if (pp->rxq_def < nr_cpu_ids && cpu_online(pp->rxq_def))

drivers/net/ethernet/marvell/octeontx2/nic/otx2_common.c

1966

if (unlikely(cpu >= nr_cpu_ids))

drivers/net/ethernet/mellanox/mlx5/core/pci_irq.c

656

table->sf_comp_pool->irqs_per_cpu = kcalloc(nr_cpu_ids, sizeof(u16), GFP_KERNEL);

drivers/net/ethernet/pensando/ionic/ionic_dev.c

77

if (cpu >= nr_cpu_ids)

drivers/net/ethernet/sfc/efx_channels.c

370

if (cpumask_first_and(cpu_online_mask, numa_mask) >= nr_cpu_ids)

drivers/net/ethernet/sfc/efx_channels.c

376

if (cpu >= nr_cpu_ids)

drivers/net/ethernet/sfc/siena/efx_channels.c

371

if (cpumask_first_and(cpu_online_mask, numa_mask) >= nr_cpu_ids)

drivers/net/ethernet/sfc/siena/efx_channels.c

377

if (cpu >= nr_cpu_ids)

drivers/net/hyperv/netvsc_drv.c

1527

pcpu_sum = kvmalloc_objs(struct netvsc_ethtool_pcpu_stats, nr_cpu_ids);

drivers/net/virtio_net.c

1586

if (v->curr_queue_pairs > nr_cpu_ids) { \

drivers/net/virtio_net.c

1604

if (v->curr_queue_pairs > nr_cpu_ids) \

drivers/net/virtio_net.c

6042

xdp_qp = nr_cpu_ids;

drivers/net/wireguard/queueing.h

109

while (unlikely(cpu >= nr_cpu_ids || !cpu_online(cpu)))

drivers/net/wireguard/queueing.h

123

if (cpu >= nr_cpu_ids)

drivers/nvdimm/nd_perf.c

155

if (target >= nr_cpu_ids) {

drivers/nvdimm/nd_perf.c

163

if (target >= 0 && target < nr_cpu_ids)

drivers/nvdimm/nd_perf.c

175

if (nd_pmu->cpu >= nr_cpu_ids)

drivers/pci/pci-driver.c

410

if (cpu < nr_cpu_ids) {

drivers/perf/alibaba_uncore_drw_pmu.c

749

if (target >= nr_cpu_ids)

drivers/perf/alibaba_uncore_drw_pmu.c

752

if (target >= nr_cpu_ids)

drivers/perf/amlogic/meson_ddr_pmu_core.c

402

if (target >= nr_cpu_ids)

drivers/perf/arm-cci.c

1439

if (target >= nr_cpu_ids)

drivers/perf/arm-ccn.c

1199

if (target >= nr_cpu_ids)

drivers/perf/arm-cmn.c

2046

if (target >= nr_cpu_ids)

drivers/perf/arm-cmn.c

2049

if (target < nr_cpu_ids)

drivers/perf/arm-ni.c

824

if (target >= nr_cpu_ids)

drivers/perf/arm-ni.c

827

if (target < nr_cpu_ids)

drivers/perf/arm_cspmu/arm_cspmu.c

1342

if (dst >= nr_cpu_ids)

drivers/perf/arm_cspmu/arm_cspmu.c

676

if (event->cpu >= nr_cpu_ids)

drivers/perf/arm_dmc620_pmu.c

647

if (target >= nr_cpu_ids)

drivers/perf/arm_dsu_pmu.c

561

if (event->cpu >= nr_cpu_ids)

drivers/perf/arm_dsu_pmu.c

833

if (dst >= nr_cpu_ids)

drivers/perf/arm_pmu_platform.c

125

if (nr_cpu_ids != 1 && !pmu_has_irq_affinity(dev->of_node))

drivers/perf/arm_pmu_platform.c

143

if (cpu >= nr_cpu_ids)

drivers/perf/arm_pmu_platform.c

86

cpu = nr_cpu_ids;

drivers/perf/arm_smmuv3_pmu.c

678

if (target >= nr_cpu_ids)

drivers/perf/cxl_pmu.c

938

if (target >= nr_cpu_ids) {

drivers/perf/dwc_pcie_pmu.c

801

if (target >= nr_cpu_ids)

drivers/perf/dwc_pcie_pmu.c

804

if (target >= nr_cpu_ids) {

drivers/perf/fsl_imx8_ddr_perf.c

767

if (target >= nr_cpu_ids)

drivers/perf/fsl_imx9_ddr_perf.c

768

if (target >= nr_cpu_ids)

drivers/perf/fujitsu_uncore_pmu.c

435

if (target >= nr_cpu_ids)

drivers/perf/fujitsu_uncore_pmu.c

438

if (target < nr_cpu_ids)

drivers/perf/hisilicon/hisi_pcie_pmu.c

720

if (target >= nr_cpu_ids)

drivers/perf/hisilicon/hisi_pcie_pmu.c

723

if (target >= nr_cpu_ids) {

drivers/perf/hisilicon/hisi_uncore_pmu.c

558

if (target >= nr_cpu_ids)

drivers/perf/hisilicon/hisi_uncore_pmu.c

561

if (target >= nr_cpu_ids)

drivers/perf/hisilicon/hns3_pmu.c

1493

if (target >= nr_cpu_ids)

drivers/perf/marvell_cn10k_ddr_pmu.c

924

if (target >= nr_cpu_ids)

drivers/perf/marvell_cn10k_tad_pmu.c

458

if (target >= nr_cpu_ids)

drivers/perf/marvell_pem_pmu.c

306

if (target >= nr_cpu_ids)

drivers/perf/nvidia_t410_c2c_pmu.c

275

if (event->cpu >= nr_cpu_ids)

drivers/perf/nvidia_t410_c2c_pmu.c

740

if (dst >= nr_cpu_ids)

drivers/perf/nvidia_t410_cmem_latency_pmu.c

186

if (event->cpu >= nr_cpu_ids)

drivers/perf/nvidia_t410_cmem_latency_pmu.c

563

if (dst >= nr_cpu_ids)

drivers/perf/qcom_l2_pmu.c

824

if (target >= nr_cpu_ids) {

drivers/perf/qcom_l3_pmu.c

713

if (target >= nr_cpu_ids)

drivers/perf/starfive_starlink_pmu.c

613

if (target >= nr_cpu_ids)

drivers/perf/thunderx2_pmu.c

588

if (tx2_pmu->cpu >= nr_cpu_ids)

drivers/perf/thunderx2_pmu.c

920

if ((tx2_pmu->cpu >= nr_cpu_ids) &&

drivers/perf/thunderx2_pmu.c

946

if (new_cpu >= nr_cpu_ids)

drivers/perf/xgene_pmu.c

1804

if (target >= nr_cpu_ids)

drivers/platform/x86/intel/ifs/sysfs.c

71

if (rc < 0 || cpu >= nr_cpu_ids)

drivers/platform/x86/intel/plr_tpmi.c

206

for (int cpu = 0; cpu < nr_cpu_ids; cpu++) {

drivers/platform/x86/intel/plr_tpmi.c

246

for (int cpu = 0; cpu < nr_cpu_ids; cpu++) {

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

215

if (cmd->logical_cpu >= nr_cpu_ids)

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

298

cpu >= nr_cpu_ids || cpu >= num_possible_cpus())

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

372

cpu >= nr_cpu_ids || cpu >= num_possible_cpus())

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

464

if (cpu_map->logical_cpu >= nr_cpu_ids ||

drivers/platform/x86/intel/speed_select_if/isst_if_common.c

496

if (msr_cmd->logical_cpu >= nr_cpu_ids)

drivers/platform/x86/intel/uncore-frequency/uncore-frequency.c

154

if (target < nr_cpu_ids)

drivers/platform/x86/intel/uncore-frequency/uncore-frequency.c

191

if (target < nr_cpu_ids) {

drivers/powercap/intel_rapl_msr.c

160

if (lead_cpu >= nr_cpu_ids) {

drivers/resctrl/mpam_resctrl.c

739

if (WARN_ON_ONCE(cpu >= nr_cpu_ids))

drivers/scsi/bnx2fc/bnx2fc.h

128

#define FCOE_XIDS_PER_CPU_OFFSET ((512 * nr_cpu_ids) - 1)

drivers/scsi/bnx2fc/bnx2fc_fcoe.c

1003

if (nr_cpu_ids <= 2)

drivers/scsi/fcoe/fcoe.c

1396

if (cpu >= nr_cpu_ids)

drivers/scsi/hpsa.c

8642

h->reply_map = kcalloc(nr_cpu_ids, sizeof(*h->reply_map), GFP_KERNEL);

drivers/scsi/libfc/fc_exch.c

2693

fc_cpu_order = ilog2(roundup_pow_of_two(nr_cpu_ids));

drivers/scsi/libfc/fc_exch.c

936

if (cpu >= nr_cpu_ids || !cpu_possible(cpu)) {

drivers/scsi/lpfc/lpfc_attr.c

5663

if (first_cpu < nr_cpu_ids)

drivers/scsi/lpfc/lpfc_init.c

12875

if ((cpu_select < nr_cpu_ids) && (cpu_select != cpu)) {

drivers/scsi/lpfc/lpfc_init.c

12988

unsigned int cpu = 0, cpu_cnt = 0, cpu_select = nr_cpu_ids;

drivers/scsi/lpfc/lpfc_init.c

13052

if (cpu_select < nr_cpu_ids)

drivers/scsi/lpfc/lpfc_init.c

13064

if (cpu >= nr_cpu_ids)

drivers/scsi/megaraid/megaraid_sas_base.c

7149

instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int),

drivers/scsi/qla2xxx/qla_inline.h

624

ha->qp_cpu_map = kzalloc_objs(struct qla_qpair *, nr_cpu_ids);

drivers/scsi/scsi_debug.c

9562

if (submit_queues > nr_cpu_ids) {

drivers/scsi/scsi_debug.c

9564

my_name, submit_queues, nr_cpu_ids);

drivers/scsi/scsi_debug.c

9565

submit_queues = nr_cpu_ids;

drivers/scsi/storvsc_drv.c

932

stor_device->stor_chns = kcalloc(nr_cpu_ids, sizeof(void *),

drivers/scsi/virtio_scsi.c

926

num_queues = min_t(unsigned int, nr_cpu_ids, num_queues);

drivers/soc/fsl/dpio/dpio-driver.c

179

if (possible_next_cpu >= nr_cpu_ids) {

drivers/soc/fsl/qbman/bman_portal.c

159

if (cpu >= nr_cpu_ids) {

drivers/soc/fsl/qbman/qman_portal.c

253

if (cpu >= nr_cpu_ids) {

drivers/target/target_core_device.c

729

dev->queues = kzalloc_objs(*dev->queues, nr_cpu_ids);

drivers/target/target_core_device.c

733

dev->queue_cnt = nr_cpu_ids;

drivers/target/target_core_fabric_configfs.c

1054

if (compl_val < 0 || compl_val >= nr_cpu_ids ||

drivers/target/target_core_iblock.c

69

ib_dev->ibd_plug = kzalloc_objs(*ib_dev->ibd_plug, nr_cpu_ids);

drivers/tee/optee/smc_abi.c

1387

if (!IS_ENABLED(CONFIG_SMP) || nr_cpu_ids == 1)

drivers/thermal/intel/x86_pkg_temp_thermal.c

388

lastcpu = target >= nr_cpu_ids;

drivers/ufs/host/ufs-mediatek.c

1923

for (cpu = 0; cpu < nr_cpu_ids; cpu++)

drivers/vdpa/vdpa_user/vduse_dev.c

1311

if (curr_cpu >= nr_cpu_ids)

drivers/virt/nitro_enclaves/ne_misc_dev.c

202

if (cpu >= nr_cpu_ids) {

drivers/virt/nitro_enclaves/ne_misc_dev.c

295

ne_cpu_pool.nr_parent_vm_cores = nr_cpu_ids / ne_cpu_pool.nr_threads_per_core;

drivers/xen/cpu_hotplug.c

57

if (cpu >= nr_cpu_ids || !cpu_possible(cpu))

drivers/xen/events/events_base.c

289

if (WARN_ON_ONCE(info->cpu >= nr_cpu_ids))

drivers/xen/events/events_base.c

297

if (WARN_ON_ONCE(info->cpu >= nr_cpu_ids))

fs/btrfs/disk-io.c

2943

(1 + ilog2(nr_cpu_ids));

fs/btrfs/disk-io.c

3463

fs_info->dirty_metadata_batch = nodesize * (1 + ilog2(nr_cpu_ids));

fs/btrfs/disk-io.c

3464

fs_info->delalloc_batch = sectorsize * 512 * (1 + ilog2(nr_cpu_ids));

fs/ext4/ext4.h

3559

#define EXT4_FREECLUSTERS_WATERMARK (4 * (percpu_counter_batch * nr_cpu_ids))

fs/fuse/virtio_fs.c

246

for (cpu = 0; cpu < nr_cpu_ids; cpu++) {

fs/fuse/virtio_fs.c

970

nr_cpu_ids);

fs/fuse/virtio_fs.c

977

fs->mq_map = kcalloc_node(nr_cpu_ids, sizeof(*fs->mq_map), GFP_KERNEL,

fs/pstore/ram.c

805

? nr_cpu_ids

fs/pstore/zone.c

1268

info->ftrace_size / nr_cpu_ids,

fs/resctrl/internal.h

32

if (cpu < nr_cpu_ids)

fs/resctrl/monitor.c

837

if (cpu < nr_cpu_ids)

fs/resctrl/monitor.c

909

if (cpu < nr_cpu_ids)

fs/seq_file.c

1130

for (*cpu = cpumask_next(*cpu, cpu_possible_mask); *cpu < nr_cpu_ids;

include/linux/backing-dev-defs.h

41

#define WB_STAT_BATCH (8*(1+ilog2(nr_cpu_ids)))

include/linux/backing-dev.h

87

return nr_cpu_ids * WB_STAT_BATCH;

include/linux/cpumask.h

1357

nr_cpu_ids, off, count) - 1;

include/linux/cpumask.h

1379

nr_cpu_ids, off, count) - 1;

include/linux/cpumask.h

29

#define cpumask_pr_args(maskp) nr_cpu_ids, cpumask_bits(maskp)

include/linux/cpumask.h

34

extern unsigned int nr_cpu_ids;

include/linux/cpumask.h

371

return find_random_bit(cpumask_bits(src), nr_cpu_ids);

include/linux/cpumask.h

40

WARN_ON(nr != nr_cpu_ids);

include/linux/cpumask.h

42

nr_cpu_ids = nr;

include/linux/cpumask.h

74

#define small_cpumask_bits nr_cpu_ids

include/linux/cpumask.h

77

#define small_cpumask_bits nr_cpu_ids

include/linux/cpumask.h

78

#define large_cpumask_bits nr_cpu_ids

include/linux/cpumask.h

80

#define nr_cpumask_bits nr_cpu_ids

include/linux/netdevice.h

822

(nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))

include/linux/netfilter/x_tables.h

448

if (nr_cpu_ids > 1)

include/linux/netfilter/x_tables.h

457

if (nr_cpu_ids > 1)

include/net/libeth/xdp.h

118

return min(max(nr_cpu_ids, rxq), max - txq);

include/net/libeth/xdp.h

129

return num < nr_cpu_ids;

io_uring/sqpoll.c

489

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

kernel/bpf/arraymap.c

299

if (cpu >= nr_cpu_ids)

kernel/bpf/cpumask.c

34

return cpu < nr_cpu_ids;

kernel/bpf/cpumask.c

462

if (src__sz < bitmap_size(nr_cpu_ids))

kernel/bpf/cpumask.c

470

bitmap_copy(cpumask_bits(cpumask), src, nr_cpu_ids);

kernel/bpf/hashtab.c

2438

if (cpu >= nr_cpu_ids)

kernel/bpf/hashtab.c

2464

if (cpu >= nr_cpu_ids)

kernel/bpf/helpers.c

718

if (cpu >= nr_cpu_ids)

kernel/bpf/verifier.c

9831

reg_set_urange64(ret_reg, 0, nr_cpu_ids - 1);

kernel/bpf/verifier.c

9832

reg_set_urange32(ret_reg, 0, nr_cpu_ids - 1);

kernel/cgroup/cpuset.c

3066

if (unlikely(cpu >= nr_cpu_ids)) {

kernel/cgroup/rstat.c

131

if (unlikely(cpu < 0 || cpu >= nr_cpu_ids || !cpu_possible(cpu)))

kernel/compat.c

150

if ((len * BITS_PER_BYTE) < nr_cpu_ids)

kernel/cpu.c

1422

housekeeping_cpumask(HK_TYPE_DOMAIN)) >= nr_cpu_ids) {

kernel/cpu.c

1907

for (cpu = nr_cpu_ids - 1; cpu >= 0; cpu--) {

kernel/crash_core.c

451

if ((cpu < 0) || (cpu >= nr_cpu_ids))

kernel/debug/kdb/kdb_main.c

2452

if (whichcpu >= nr_cpu_ids || !cpu_online(whichcpu)) {

kernel/events/callchain.c

83

size = offsetof(struct callchain_cpus_entries, cpu_entries[nr_cpu_ids]);

kernel/events/core.c

13140

if (cpu >= nr_cpu_ids)

kernel/events/core.c

13357

if ((unsigned)cpu >= nr_cpu_ids) {

kernel/events/core.c

15186

if (target[scope] < nr_cpu_ids)

kernel/events/core.c

15196

if (target[pmu->scope] >= 0 && target[pmu->scope] < nr_cpu_ids)

kernel/events/core.c

15258

cpumask_any_and(pmu_cpumask, cpumask) >= nr_cpu_ids)

kernel/events/core.c

4787

if ((unsigned)event_cpu >= nr_cpu_ids)

kernel/events/core.c

4979

if ((unsigned)event_cpu >= nr_cpu_ids)

kernel/irq/cpuhotplug.c

39

if (cpumask_any_but(m, cpu) < nr_cpu_ids &&

kernel/irq/ipi.c

168

if (!data || cpu >= nr_cpu_ids)

kernel/irq/ipi.c

199

if (cpu >= nr_cpu_ids)

kernel/irq/ipi.c

70

if (next < nr_cpu_ids)

kernel/irq/ipi.c

72

if (next < nr_cpu_ids) {

kernel/padata.c

848

nr_cpu_ids, cpumask_bits(cpumask));

kernel/panic.c

319

if (kstrtoint(str, 0, &cpu) || cpu < 0 || cpu >= nr_cpu_ids) {

kernel/power/energy_model.c

499

if (cpu >= nr_cpu_ids) {

kernel/rcu/rcu.h

379

cprv = nr_cpu_ids;

kernel/rcu/rcuscale.c

450

set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids));

kernel/rcu/rcuscale.c

537

set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids));

kernel/rcu/rcuscale.c

735

set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids));

kernel/rcu/rcutorture.c

3650

if (fwd_progress >= nr_cpu_ids) {

kernel/rcu/rcutorture.c

3652

fwd_progress = nr_cpu_ids;

kernel/rcu/rcutorture.c

3654

fwd_progress = nr_cpu_ids;

kernel/rcu/rcutorture.c

4000

if (dumpcpu >= nr_cpu_ids)

kernel/rcu/rcutorture.c

4024

if (cpu >= nr_cpu_ids)

kernel/rcu/rcutorture.c

4026

WARN_ON_ONCE(cpu >= nr_cpu_ids);

kernel/rcu/refscale.c

1132

si = -si * nr_cpu_ids;

kernel/rcu/refscale.c

1134

si = nr_cpu_ids;

kernel/rcu/refscale.c

1235

WARN_ON_ONCE(set_cpus_allowed_ptr(current, cpumask_of(me % nr_cpu_ids)));

kernel/rcu/refscale.c

1251

WARN_ON_ONCE(raw_smp_processor_id() != me % nr_cpu_ids);

kernel/rcu/refscale.c

1365

set_cpus_allowed_ptr(current, cpumask_of(nreaders % nr_cpu_ids));

kernel/rcu/srcutree.c

2105

if (nr_cpu_ids >= big_cpu_lim) {

kernel/rcu/tree.c

471

if (j < HZ / 10 + nr_cpu_ids / RCU_JIFFIES_FQS_DIV)

kernel/rcu/tree.c

472

j = HZ / 10 + nr_cpu_ids / RCU_JIFFIES_FQS_DIV;

kernel/rcu/tree.c

4724

if (rnp->grphi >= nr_cpu_ids)

kernel/rcu/tree.c

4725

rnp->grphi = nr_cpu_ids - 1;

kernel/rcu/tree.c

4804

WARN_ON_ONCE(old_nr_cpu_ids != nr_cpu_ids);

kernel/rcu/tree.c

4808

old_nr_cpu_ids = nr_cpu_ids;

kernel/rcu/tree.c

4818

d = RCU_JIFFIES_TILL_FORCE_QS + nr_cpu_ids / RCU_JIFFIES_FQS_DIV;

kernel/rcu/tree.c

4827

nr_cpu_ids == NR_CPUS)

kernel/rcu/tree.c

4830

rcu_fanout_leaf, nr_cpu_ids);

kernel/rcu/tree.c

4856

if (nr_cpu_ids > rcu_capacity[RCU_NUM_LVLS - 1]) {

kernel/rcu/tree.c

4863

for (i = 0; nr_cpu_ids > rcu_capacity[i]; i++) {

kernel/rcu/tree.c

4870

num_rcu_lvl[i] = DIV_ROUND_UP(nr_cpu_ids, cap);

kernel/rcu/tree_nocb.h

1456

ls = nr_cpu_ids / int_sqrt(nr_cpu_ids);

kernel/rcu/tree_plugin.h

67

if (nr_cpu_ids != NR_CPUS)

kernel/rcu/tree_plugin.h

68

pr_info("\tRCU restricting CPUs from NR_CPUS=%d to nr_cpu_ids=%u.\n", NR_CPUS, nr_cpu_ids);

kernel/scftorture.c

372

cpu = torture_random(trsp) % nr_cpu_ids;

kernel/scftorture.c

379

cpu = torture_random(trsp) % nr_cpu_ids;

kernel/scftorture.c

402

cpu = torture_random(trsp) % nr_cpu_ids;

kernel/scftorture.c

485

cpu = scfp->cpu % nr_cpu_ids;

kernel/scftorture.c

497

__func__, scfp->cpu, curcpu, nr_cpu_ids);

kernel/scftorture.c

563

for (i = 0; i < nr_cpu_ids; i++)

kernel/scftorture.c

599

weight_resched1 = weight_resched == 0 ? 0 : 2 * nr_cpu_ids;

kernel/scftorture.c

600

weight_single1 = weight_single == 0 ? 0 : 2 * nr_cpu_ids;

kernel/scftorture.c

601

weight_single_rpc1 = weight_single_rpc == 0 ? 0 : 2 * nr_cpu_ids;

kernel/scftorture.c

602

weight_single_wait1 = weight_single_wait == 0 ? 0 : 2 * nr_cpu_ids;

kernel/sched/core.c

3173

if (dest_cpu >= nr_cpu_ids) {

kernel/sched/core.c

8942

ptr += 2 * nr_cpu_ids * sizeof(void **);

kernel/sched/core.c

8945

ptr += nr_cpu_ids * sizeof(void **);

kernel/sched/core.c

8948

ptr += nr_cpu_ids * sizeof(void **);

kernel/sched/cpudeadline.c

255

cp->elements = kzalloc_objs(struct cpudl_item, nr_cpu_ids);

kernel/sched/cpupri.c

100

if (cpumask_any_and(&p->cpus_mask, vec->mask) >= nr_cpu_ids)

kernel/sched/cpupri.c

291

cp->cpu_to_pri = kzalloc_objs(int, nr_cpu_ids);

kernel/sched/deadline.c

2995

if (best_cpu < nr_cpu_ids) {

kernel/sched/deadline.c

3011

if (cpu < nr_cpu_ids)

kernel/sched/deadline.c

3438

BUG_ON(cpu >= nr_cpu_ids);

kernel/sched/deadline.c

662

if (cpu >= nr_cpu_ids) {

kernel/sched/debug.c

1265

if (n < nr_cpu_ids)

kernel/sched/ext/cid.c

113

for (cpu = 0; cpu < nr_cpu_ids; cpu++)

kernel/sched/ext/cid.c

317

if (cpu_to_cid__sz != nr_cpu_ids * sizeof(s32)) {

kernel/sched/ext/cid.c

319

nr_cpu_ids * sizeof(s32), cpu_to_cid__sz);

kernel/sched/ext/cid.c

57

cpu_to_cid = kzalloc_objs(*scx_cpu_to_cid_tbl, nr_cpu_ids, GFP_KERNEL);

kernel/sched/ext/ext.c

10067

return nr_cpu_ids;

kernel/sched/ext/ext.c

1080

return likely(cpu >= 0 && cpu < nr_cpu_ids && cpu_possible(cpu));

kernel/sched/ext/ext.c

5306

if (donee >= nr_cpu_ids)

kernel/sched/ext/ext.c

6725

new_ksyncs = kvzalloc_node(struct_size(new_ksyncs, syncs, nr_cpu_ids),

kernel/sched/ext/ext.c

6791

s32 node, cpu, ret, bypass_fail_cpu = nr_cpu_ids;

kernel/sched/ext/idle.c

122

if (cpu < nr_cpu_ids)

kernel/sched/ext/idle.c

130

if (cpu >= nr_cpu_ids)

kernel/sched/ext/idle.c

1408

if (cpu < nr_cpu_ids)

kernel/sched/ext/idle.c

1456

if (cpu < nr_cpu_ids)

kernel/sched/fair.c

10774

if (cpu < nr_cpu_ids) {

kernel/sched/fair.c

2571

return cpupid_to_cpu(cpupid) < nr_cpu_ids;

kernel/sched/isolation.c

230

if (first_cpu >= nr_cpu_ids || first_cpu >= setup_max_cpus) {

kernel/sched/isolation.c

277

if (first_cpu >= min(nr_cpu_ids, setup_max_cpus)) {

kernel/sched/isolation.c

85

if (cpu < nr_cpu_ids)

kernel/sched/isolation.c

89

if (likely(cpu < nr_cpu_ids))

kernel/sched/membarrier.c

375

if (cpu_id >= nr_cpu_ids || !cpu_possible(cpu_id))

kernel/sched/rt.c

1842

if (best_cpu < nr_cpu_ids) {

kernel/sched/rt.c

1859

if (cpu < nr_cpu_ids)

kernel/sched/rt.c

2157

if (cpu < nr_cpu_ids)

kernel/sched/rt.c

262

tg->rt_rq = kzalloc_objs(rt_rq, nr_cpu_ids);

kernel/sched/rt.c

265

tg->rt_se = kzalloc_objs(rt_se, nr_cpu_ids);

kernel/sched/sched.h

2078

return nr_cpu_ids;

kernel/sched/stats.c

191

if (n < nr_cpu_ids)

kernel/sched/syscalls.c

1313

if ((len * BITS_PER_BYTE) < nr_cpu_ids)

kernel/sched/topology.c

2535

int i, j = cpu_to_node(cpu), found = nr_cpu_ids;

kernel/sched/topology.c

2546

if (cpu < nr_cpu_ids) {

kernel/sched/topology.c

2600

int hop, ret = nr_cpu_ids;

kernel/sched/topology.c

3032

if (lid >= nr_cpu_ids)

kernel/sched/topology.c

3050

if (lid == -1 || lid >= nr_cpu_ids)

kernel/sched/topology.c

3122

j < nr_cpu_ids;

kernel/smp.c

1014

unsigned int nr_cpu_ids __read_mostly = NR_CPUS;

kernel/smp.c

1015

EXPORT_SYMBOL(nr_cpu_ids);

kernel/smp.c

1205

if (cpu >= nr_cpu_ids || !cpu_online(cpu))

kernel/smp.c

271

if (WARN_ONCE(cpu < 0 || cpu >= nr_cpu_ids, "%s: cpu = %d\n", __func__, cpu))

kernel/smp.c

403

(unsigned int)cpu < nr_cpu_ids)

kernel/smp.c

479

if ((unsigned)cpu >= nr_cpu_ids || !cpu_online(cpu)) {

kernel/smp.c

847

if (cpumask_any_and_but(mask, cpu_online_mask, this_cpu) < nr_cpu_ids) {

kernel/smp.c

993

if (get_option(&str, &nr_cpus) && nr_cpus > 0 && nr_cpus < nr_cpu_ids)

kernel/time/timer_list.c

301

if (iter->cpu >= nr_cpu_ids) {

kernel/time/timer_migration.c

1529

if (migrator < nr_cpu_ids) {

kernel/time/timer_migration.c

2057

if (target < nr_cpu_ids) {

kernel/torture.c

542

if (shuffle_idle_cpu >= nr_cpu_ids)

kernel/trace/ring_buffer.c

2190

for (cpu = 0; cpu < nr_cpu_ids; cpu++) {

kernel/trace/ring_buffer.c

2205

if (cpu < nr_cpu_ids - 1)

kernel/trace/ring_buffer.c

2742

buffer->cpus = nr_cpu_ids;

kernel/trace/ring_buffer.c

2744

bsize = sizeof(void *) * nr_cpu_ids;

kernel/trace/ring_buffer.c

2771

size = size / nr_cpu_ids;

kernel/trace/ring_buffer.c

2788

for (n = 0, ptr = buffers_start; n < nr_cpu_ids; n++) {

kernel/trace/ring_buffer.c

868

if (WARN_ON_ONCE(cpu >= nr_cpu_ids))

kernel/trace/trace.c

3380

iter->buffer_iter = kzalloc_objs(*iter->buffer_iter, nr_cpu_ids);

kernel/trace/trace_event_perf.c

492

ops->private = (void *)(unsigned long)nr_cpu_ids;

kernel/trace/trace_event_perf.c

535

event->ftrace_ops.private = (void *)(unsigned long)nr_cpu_ids;

kernel/trace/trace_events_filter.c

693

cpumask_nth(1, mask) >= nr_cpu_ids;

kernel/trace/trace_events_filter.c

696

cpumask_nth(1, mask) < nr_cpu_ids;

kernel/trace/trace_events_filter.c

753

if (cpu >= nr_cpu_ids) \

kernel/trace/trace_functions_graph.c

1816

max_bytes_for_cpu = snprintf(NULL, 0, "%u", nr_cpu_ids - 1);

kernel/trace/trace_hwlat.c

330

if (next_cpu >= nr_cpu_ids) /* Shouldn't happen! */

kernel/trace/trace_remote.c

254

remote->pcpu_reader_locks = kcalloc(nr_cpu_ids, sizeof(*remote->pcpu_reader_locks),

kernel/trace/trace_remote.c

327

iter->rb_iters = kcalloc(nr_cpu_ids, sizeof(*iter->rb_iters), GFP_KERNEL);

kernel/watchdog_buddy.c

17

return nr_cpu_ids;

kernel/watchdog_buddy.c

49

if (next_cpu < nr_cpu_ids)

kernel/watchdog_buddy.c

73

if (next_cpu < nr_cpu_ids)

kernel/watchdog_buddy.c

92

if (next_cpu >= nr_cpu_ids)

kernel/workqueue.c

1307

if (wake_cpu < nr_cpu_ids) {

kernel/workqueue.c

2268

if (unlikely(new_cpu >= nr_cpu_ids))

kernel/workqueue.c

2487

return cpu < nr_cpu_ids ? cpu : WORK_CPU_UNBOUND;

kernel/workqueue.c

5410

ctx = kzalloc_flex(*ctx, pwq_tbl, nr_cpu_ids);

kernel/workqueue.c

8010

pt->cpu_pod = kzalloc_objs(pt->cpu_pod[0], nr_cpu_ids);

kernel/workqueue.c

8193

pt->cpu_pod = kzalloc_objs(pt->cpu_pod[0], nr_cpu_ids);

kernel/workqueue.c

8366

if (WARN_ON_ONCE(leader >= nr_cpu_ids))

lib/cpu_rmap.c

36

obj_offset = ALIGN(offsetof(struct cpu_rmap, near[nr_cpu_ids]),

lib/cpumask.c

117

WARN_ON(cpu >= nr_cpu_ids);

lib/cpumask.c

143

if (next < nr_cpu_ids)

lib/cpumask.c

163

if (next < nr_cpu_ids)

lib/flex_proportions.c

128

if (val < (nr_cpu_ids * PROP_BATCH))

lib/flex_proportions.c

90

#define PROP_BATCH (8*(1+ilog2(nr_cpu_ids)))

lib/group_cpus.c

24

if (cpu >= nr_cpu_ids)

lib/group_cpus.c

307

if (cpu >= nr_cpu_ids)

lib/group_cpus.c

35

if (sibl >= nr_cpu_ids)

lib/objpool.c

112

for (i = 0; i < nr_cpu_ids; i++)

lib/objpool.c

145

slot_size = nr_cpu_ids * sizeof(struct objpool_slot *);

lib/objpool.c

53

for (i = 0; i < nr_cpu_ids; i++) {

lib/tests/cpumask_kunit.c

44

for_each_cpu_wrap(cpu, m, nr_cpu_ids / 2) \

lib/tests/cpumask_kunit.c

68

KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(cpu_possible_mask),

lib/tests/cpumask_kunit.c

70

KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(&mask_all), MASK_MSG(&mask_all));

lib/tests/cpumask_kunit.c

75

KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_first(&mask_empty), MASK_MSG(&mask_empty));

lib/tests/cpumask_kunit.c

79

KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_first_zero(cpu_possible_mask),

lib/tests/cpumask_kunit.c

87

KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids - 1, cpumask_last(cpu_possible_mask),

lib/tests/cpumask_kunit.c

94

KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_next_zero(-1, cpu_possible_mask),

lib/tests/cpumask_kunit.c

97

KUNIT_EXPECT_LE_MSG(test, nr_cpu_ids, cpumask_next(-1, &mask_empty),

mm/percpu.c

2613

alloc_size = nr_cpu_ids * sizeof(unit_map[0]);

mm/percpu.c

2616

alloc_size = nr_cpu_ids * sizeof(unit_off[0]);

mm/percpu.c

2619

for (cpu = 0; cpu < nr_cpu_ids; cpu++)

mm/percpu.c

2636

PCPU_SETUP_BUG_ON(cpu >= nr_cpu_ids);

mm/slub.c

7528

nr_cpus = nr_cpu_ids;

mm/slub.c

8595

nr_cpu_ids, nr_node_ids);

mm/slub.c

9362

int *data = kmalloc_objs(int, nr_cpu_ids);

mm/vmalloc.c

2653

int index = (addr / VMAP_BLOCK_SIZE) % nr_cpu_ids;

net/bpf/test_run.c

830

} else if (cpu >= nr_cpu_ids || !cpu_online(cpu)) {

net/bridge/netfilter/ebtables.c

1137

countersize = COUNTER_OFFSET(tmp.nentries) * nr_cpu_ids;

net/bridge/netfilter/ebtables.c

1203

countersize = COUNTER_OFFSET(repl->nentries) * nr_cpu_ids;

net/bridge/netfilter/ebtables.c

2308

countersize = COUNTER_OFFSET(tmp.nentries) * nr_cpu_ids;

net/bridge/netfilter/ebtables.c

927

vcalloc(nr_cpu_ids, sizeof(*(newinfo->chainstack)));

net/core/dev.c

2887

nr_ids = nr_cpu_ids;

net/core/dev.c

5032

if (cpu >= nr_cpu_ids)

net/core/dev.c

5047

if (next_cpu < nr_cpu_ids) {

net/core/dev.c

5190

(tcpu >= nr_cpu_ids || !cpu_online(tcpu) ||

net/core/dev.c

5197

if (tcpu < nr_cpu_ids && cpu_online(tcpu)) {

net/core/dev.c

6569

return kmalloc_flex(struct flush_backlogs, w, nr_cpu_ids);

net/core/neighbour.c

3484

for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {

net/core/neighbour.c

3498

for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {

net/core/net-procfs.c

99

while (*pos < nr_cpu_ids)

net/core/net-sysfs.c

1707

(type == XPS_CPUS ? nr_cpu_ids : dev->num_rx_queues);

net/core/skbuff.c

7323

WARN_ON_ONCE(cpu >= nr_cpu_ids) ||

net/core/sysctl_net_core.c

183

roundup_pow_of_two(nr_cpu_ids) - 1;

net/ipv4/route.c

241

for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {

net/ipv4/route.c

254

for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {

net/netfilter/ipvs/ip_vs_core.c

185

int ml = roundup_pow_of_two(nr_cpu_ids);

net/netfilter/nf_conntrack_netlink.c

2528

if (cb->args[0] == nr_cpu_ids)

net/netfilter/nf_conntrack_netlink.c

2531

for (cpu = cb->args[0]; cpu < nr_cpu_ids; cpu++) {

net/netfilter/nf_conntrack_netlink.c

3717

if (cb->args[0] == nr_cpu_ids)

net/netfilter/nf_conntrack_netlink.c

3720

for (cpu = cb->args[0]; cpu < nr_cpu_ids; cpu++) {

net/netfilter/nf_conntrack_standalone.c

408

for (cpu = *pos-1; cpu < nr_cpu_ids; ++cpu) {

net/netfilter/nf_conntrack_standalone.c

423

for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {

net/netfilter/nf_flow_table_procfs.c

14

for (cpu = *pos - 1; cpu < nr_cpu_ids; ++cpu) {

net/netfilter/nf_flow_table_procfs.c

29

for (cpu = *pos; cpu < nr_cpu_ids; ++cpu) {

net/netfilter/nf_synproxy_core.c

251

for (cpu = *pos - 1; cpu < nr_cpu_ids; cpu++) {

net/netfilter/nf_synproxy_core.c

266

for (cpu = *pos; cpu < nr_cpu_ids; cpu++) {

net/netfilter/x_tables.c

1425

size = sizeof(void **) * nr_cpu_ids;

net/netfilter/x_tables.c

2133

if (nr_cpu_ids <= 1)

net/netfilter/x_tables.c

2156

if (nr_cpu_ids > 1 && (pcnt & (XT_PCPU_BLOCK_SIZE - 1)) == 0)

net/openvswitch/datapath.c

1592

msgsize += nla_total_size(sizeof(u32) * nr_cpu_ids); /* OVS_DP_ATTR_PER_CPU_PIDS */

net/openvswitch/datapath.c

1636

pids_len = min(pids->n_pids, nr_cpu_ids) * sizeof(u32);

net/openvswitch/datapath.c

2211

msgsize += nla_total_size(nr_cpu_ids * sizeof(u32));

net/openvswitch/flow_table.c

1193

+ (nr_cpu_ids

net/openvswitch/flow_table.c

82

flow->cpu_used_mask = (struct cpumask *)&flow->stats[nr_cpu_ids];

net/openvswitch/vport.c

409

if (nla_len(ids) / sizeof(u32) > nr_cpu_ids)

net/sunrpc/svc.c

233

unsigned int maxpools = nr_cpu_ids;

security/selinux/selinuxfs.c

1402

for (cpu = *idx; cpu < nr_cpu_ids; ++cpu) {

tools/sched_ext/include/scx/cid.bpf.h

685

u32 nr_cpu_ids = scx_bpf_nr_cpu_ids();

tools/sched_ext/include/scx/cid.bpf.h

689

bpf_for(cpu, 0, nr_cpu_ids) {

tools/sched_ext/scx_central.bpf.c

231

bpf_for(cpu, 0, nr_cpu_ids) {

tools/sched_ext/scx_central.bpf.c

238

gimme = ARRAY_ELEM_PTR(cpu_gimme_task, cpu, nr_cpu_ids);

tools/sched_ext/scx_central.bpf.c

269

gimme = ARRAY_ELEM_PTR(cpu_gimme_task, cpu, nr_cpu_ids);

tools/sched_ext/scx_central.bpf.c

284

u64 *started_at = ARRAY_ELEM_PTR(cpu_started_at, cpu, nr_cpu_ids);

tools/sched_ext/scx_central.bpf.c

292

u64 *started_at = ARRAY_ELEM_PTR(cpu_started_at, cpu, nr_cpu_ids);

tools/sched_ext/scx_central.bpf.c

310

bpf_for(i, 0, nr_cpu_ids) {

tools/sched_ext/scx_central.bpf.c

311

s32 cpu = (nr_timers + i) % nr_cpu_ids;

tools/sched_ext/scx_central.bpf.c

318

started_at = ARRAY_ELEM_PTR(cpu_started_at, cpu, nr_cpu_ids);

tools/sched_ext/scx_central.bpf.c

59

const volatile u32 nr_cpu_ids = 1; /* !0 for veristat, set during init */

tools/sched_ext/scx_central.c

60

skel->rodata->nr_cpu_ids = libbpf_num_possible_cpus();

tools/sched_ext/scx_central.c

63

assert(skel->rodata->nr_cpu_ids > 0);

tools/sched_ext/scx_central.c

64

assert(skel->rodata->nr_cpu_ids <= INT32_MAX);

tools/sched_ext/scx_central.c

73

if (central_cpu >= skel->rodata->nr_cpu_ids) {

tools/sched_ext/scx_central.c

74

fprintf(stderr, "invalid central CPU id value, %u given (%u max)\n", central_cpu, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_central.c

91

RESIZE_ARRAY(skel, data, cpu_gimme_task, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_central.c

92

RESIZE_ARRAY(skel, data, cpu_started_at, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_pair.bpf.c

124

const volatile u32 nr_cpu_ids = 1;

tools/sched_ext/scx_pair.bpf.c

294

vptr = (u32 *)ARRAY_ELEM_PTR(pair_id, cpu, nr_cpu_ids);

tools/sched_ext/scx_pair.bpf.c

302

vptr = (u32 *)ARRAY_ELEM_PTR(in_pair_idx, cpu, nr_cpu_ids);

tools/sched_ext/scx_pair.bpf.c

486

s32 *pair = (s32 *)ARRAY_ELEM_PTR(pair_cpu, cpu, nr_cpu_ids);

tools/sched_ext/scx_pair.bpf.c

521

s32 *pair = (s32 *)ARRAY_ELEM_PTR(pair_cpu, cpu, nr_cpu_ids);

tools/sched_ext/scx_pair.bpf.c

550

s32 *pair = (s32 *)ARRAY_ELEM_PTR(pair_cpu, cpu, nr_cpu_ids);

tools/sched_ext/scx_pair.c

101

for (i = 0; i < skel->rodata->nr_cpu_ids; i++)

tools/sched_ext/scx_pair.c

105

for (i = 0; i < skel->rodata->nr_cpu_ids; i++) {

tools/sched_ext/scx_pair.c

106

int j = (i + stride) % skel->rodata->nr_cpu_ids;

tools/sched_ext/scx_pair.c

60

skel->rodata->nr_cpu_ids = libbpf_num_possible_cpus();

tools/sched_ext/scx_pair.c

64

stride = skel->rodata->nr_cpu_ids / 2;

tools/sched_ext/scx_pair.c

87

if (skel->rodata->nr_cpu_ids & 1) {

tools/sched_ext/scx_pair.c

89

skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_pair.c

94

bpf_map__set_max_entries(skel->maps.pair_ctx, skel->rodata->nr_cpu_ids / 2);

tools/sched_ext/scx_pair.c

97

RESIZE_ARRAY(skel, rodata, pair_cpu, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_pair.c

98

RESIZE_ARRAY(skel, rodata, pair_id, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_pair.c

99

RESIZE_ARRAY(skel, rodata, in_pair_idx, skel->rodata->nr_cpu_ids);

tools/sched_ext/scx_qmap.bpf.c

1074

u32 nr_cids, nr_cpu_ids;

tools/sched_ext/scx_qmap.bpf.c

1079

nr_cpu_ids = scx_bpf_nr_cpu_ids();

tools/sched_ext/scx_qmap.bpf.c

1086

if (nr_cpu_ids > SCX_QMAP_MAX_CPUS) {

tools/sched_ext/scx_qmap.bpf.c

1088

nr_cpu_ids, SCX_QMAP_MAX_CPUS);

tools/sched_ext/scx_qmap.bpf.c

1099

nr_cpu_ids * sizeof(s32));

tools/testing/selftests/mm/page_frag/page_frag_test.c

134

test_push_cpu < 0 || test_push_cpu >= nr_cpu_ids ||

tools/testing/selftests/mm/page_frag/page_frag_test.c

135

test_pop_cpu < 0 || test_pop_cpu >= nr_cpu_ids ||

virt/kvm/kvm_main.c

3839

if (cpu != me && (unsigned int)cpu < nr_cpu_ids && cpu_online(cpu)) {