arch/alpha/lib/srm_puts.c

12

long remaining, written;

arch/alpha/lib/srm_puts.c

17

for (remaining = len; remaining > 0; remaining -= written)

arch/alpha/lib/srm_puts.c

19

written = callback_puts(0, str, remaining);

arch/mips/boot/elf2ecoff.c

71

int remaining, cur, count;

arch/mips/boot/elf2ecoff.c

79

remaining = size;

arch/mips/boot/elf2ecoff.c

80

while (remaining) {

arch/mips/boot/elf2ecoff.c

81

cur = remaining;

arch/mips/boot/elf2ecoff.c

84

remaining -= cur;

arch/powerpc/include/asm/guest-state-buffer.h

525

int remaining)

arch/powerpc/include/asm/guest-state-buffer.h

527

return remaining >= kvmppc_gse_total_len(gse);

arch/powerpc/include/asm/guest-state-buffer.h

539

kvmppc_gse_next(const struct kvmppc_gs_elem *gse, int *remaining)

arch/powerpc/include/asm/guest-state-buffer.h

543

*remaining -= len;

arch/s390/include/uapi/asm/kvm.h

47

__u64 remaining;

arch/s390/kvm/dat.c

1173

atomic64_t *remaining;

arch/s390/kvm/dat.c

1236

atomic64_dec(state->remaining);

arch/s390/kvm/dat.c

1248

.remaining = rem,

arch/s390/kvm/kvm-s390.c

2242

args->remaining = atomic64_read(&kvm->arch.cmma_dirty_pages);

arch/s390/kvm/kvm-s390.c

2244

args->remaining = 0;

arch/um/drivers/cow_user.c

149

int remaining;

arch/um/drivers/cow_user.c

171

remaining = size - strlen(to);

arch/um/drivers/cow_user.c

172

if (strlen(slash) + 1 > remaining) {

arch/x86/kvm/i8254.c

100

remaining = hrtimer_get_remaining(&ps->timer);

arch/x86/kvm/i8254.c

101

elapsed = ps->period - ktime_to_ns(remaining);

arch/x86/kvm/i8254.c

85

ktime_t remaining;

arch/x86/kvm/lapic.c

1656

ktime_t remaining, now;

arch/x86/kvm/lapic.c

1665

remaining = ktime_sub(apic->lapic_timer.target_expiration, now);

arch/x86/kvm/lapic.c

1666

if (ktime_to_ns(remaining) < 0)

arch/x86/kvm/lapic.c

1667

remaining = 0;

arch/x86/kvm/lapic.c

1669

ns = mod_64(ktime_to_ns(remaining), apic->lapic_timer.period);

arch/x86/kvm/lapic.c

2102

ktime_t now, remaining;

arch/x86/kvm/lapic.c

2110

remaining = ktime_sub(apic->lapic_timer.target_expiration, now);

arch/x86/kvm/lapic.c

2111

if (ktime_to_ns(remaining) < 0)

arch/x86/kvm/lapic.c

2112

remaining = 0;

arch/x86/kvm/lapic.c

2114

ns_remaining_old = ktime_to_ns(remaining);

arch/x86/kvm/vmx/nested.c

4495

ktime_t remaining =

arch/x86/kvm/vmx/nested.c

4499

if (ktime_to_ns(remaining) <= 0)

arch/x86/kvm/vmx/nested.c

4502

value = ktime_to_ns(remaining) * vcpu->arch.virtual_tsc_khz;

crypto/testmgr.c

1018

unsigned int remaining = TEST_SG_TOTAL;

crypto/testmgr.c

1025

this_len = remaining;

crypto/testmgr.c

1027

this_len = (remaining + 1) / 2;

crypto/testmgr.c

1029

this_len = prandom_u32_inclusive(rng, 1, remaining);

crypto/testmgr.c

1083

div->offset, this_len == remaining ? "" : ", ");

crypto/testmgr.c

1084

remaining -= this_len;

crypto/testmgr.c

1086

} while (remaining);

crypto/testmgr.c

473

unsigned int remaining = TEST_SG_TOTAL;

crypto/testmgr.c

477

remaining -= divs[ndivs++].proportion_of_total;

crypto/testmgr.c

478

} while (remaining);

drivers/accel/qaic/qaic_control.c

397

u64 xfer_start_addr, remaining, end, total;

drivers/accel/qaic/qaic_control.c

410

remaining = in_trans->size - resources->xferred_dma_size;

drivers/accel/qaic/qaic_control.c

411

if (remaining == 0)

drivers/accel/qaic/qaic_control.c

414

if (check_add_overflow(xfer_start_addr, remaining, &end))

drivers/accel/qaic/qaic_control.c

417

total = remaining + offset_in_page(xfer_start_addr);

drivers/accel/qaic/qaic_control.c

454

remaining, GFP_KERNEL);

drivers/atm/nicstar.c

2227

int remaining, tocopy;

drivers/atm/nicstar.c

2296

remaining = len - iov->iov_len;

drivers/atm/nicstar.c

2305

min_t(int, remaining, iov->iov_len);

drivers/atm/nicstar.c

2311

remaining -= tocopy;

drivers/atm/nicstar.c

2315

if (remaining != 0 || hb->len != len)

drivers/block/floppy.c

2430

int remaining; /* number of transferred 512-byte sectors */

drivers/block/floppy.c

2445

remaining = current_count_sectors << 9;

drivers/block/floppy.c

2446

if (remaining > blk_rq_bytes(current_req) && CT(raw_cmd->cmd[COMMAND]) == FD_WRITE) {

drivers/block/floppy.c

2449

pr_info("remaining=%d\n", remaining >> 9);

drivers/block/floppy.c

2465

if (!remaining)

drivers/block/floppy.c

2469

SUPBOUND(size, remaining);

drivers/block/floppy.c

2491

remaining -= size;

drivers/block/floppy.c

2494

if (remaining) {

drivers/block/floppy.c

2495

if (remaining > 0)

drivers/block/floppy.c

2496

max_sector -= remaining >> 9;

drivers/block/floppy.c

2497

DPRINT("weirdness: remaining %d\n", remaining >> 9);

drivers/char/mem.c

117

unsigned long remaining;

drivers/char/mem.c

130

remaining = clear_user(buf, sz);

drivers/char/mem.c

146

remaining = copy_to_user(buf, bounce, sz);

drivers/char/mem.c

149

if (remaining)

drivers/char/ps3flash.c

100

size_t remaining, n;

drivers/char/ps3flash.c

121

remaining = count;

drivers/char/ps3flash.c

123

n = min_t(u64, remaining, dev->bounce_size - offset);

drivers/char/ps3flash.c

150

remaining -= n;

drivers/char/ps3flash.c

153

} while (remaining > 0);

drivers/char/ps3flash.c

169

size_t remaining, n;

drivers/char/ps3flash.c

190

remaining = count;

drivers/char/ps3flash.c

192

n = min_t(u64, remaining, dev->bounce_size - offset);

drivers/char/ps3flash.c

225

remaining -= n;

drivers/char/ps3flash.c

228

} while (remaining > 0);

drivers/char/tpm/tpm_tis_spi_cr50.c

92

unsigned long remaining, timeout = allowed_access - time_now;

drivers/char/tpm/tpm_tis_spi_cr50.c

94

remaining = wait_for_completion_timeout(&phy->spi_phy.ready,

drivers/char/tpm/tpm_tis_spi_cr50.c

96

if (!remaining && phy->irq_confirmed)

drivers/clk/clk-rpmi.c

108

__le32 remaining;

drivers/clk/clk-rpmi.c

257

while (le32_to_cpu(resp->remaining)) {

drivers/crypto/bcm/cipher.c

308

int remaining; /* Bytes of request still to process */

drivers/crypto/bcm/cipher.c

333

remaining = rctx->total_todo - chunk_start;

drivers/crypto/bcm/cipher.c

337

(remaining > ctx->max_payload))

drivers/crypto/bcm/cipher.c

340

chunksize = remaining;

drivers/crypto/bcm/cipher.c

394

rctx->src_sent, chunk_start, remaining, chunksize);

drivers/crypto/marvell/cesa/cipher.c

267

int remaining;

drivers/crypto/marvell/cesa/cipher.c

276

remaining = (ctx->aes.key_length - 16) / 4;

drivers/crypto/marvell/cesa/cipher.c

277

offset = ctx->aes.key_length + 24 - remaining;

drivers/crypto/marvell/cesa/cipher.c

278

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

drivers/cxl/core/mbox.c

669

u32 remaining = *size;

drivers/cxl/core/mbox.c

672

while (remaining) {

drivers/cxl/core/mbox.c

673

u32 xfer_size = min_t(u32, remaining, cxl_mbox->payload_size);

drivers/cxl/core/mbox.c

708

remaining -= xfer_size;

drivers/cxl/core/memdev.c

910

u32 cur_size, remaining;

drivers/cxl/core/memdev.c

932

remaining = size - cur_size;

drivers/cxl/core/memdev.c

958

} else if (remaining == 0) {

drivers/cxl/core/memdev.c

983

if (mds->fw.oneshot || remaining == 0) {

drivers/cxl/core/pci.c

495

size_t received, remaining = *length;

drivers/cxl/core/pci.c

507

rsp, sizeof(*rsp) + remaining);

drivers/cxl/core/pci.c

537

remaining -= received;

drivers/cxl/core/pci.c

543

*length -= remaining;

drivers/dma/stm32/stm32-dma.c

306

u32 remaining;

drivers/dma/stm32/stm32-dma.c

317

remaining = ((STM32_DMA_FIFO_SIZE / width) *

drivers/dma/stm32/stm32-dma.c

320

if (remaining == 0)

drivers/dma/stm32/stm32-dma3.c

1259

size_t remaining;

drivers/dma/stm32/stm32-dma3.c

1262

remaining = len - offset;

drivers/dma/stm32/stm32-dma3.c

1263

next_size = min_t(size_t, remaining, STM32_DMA3_MAX_BLOCK_SIZE);

drivers/dma/stm32/stm32-dma3.c

1267

next_size = chan->max_burst * (remaining / chan->max_burst);

drivers/dma/stm32/stm32-dma3.c

1275

ctr1, ctr2, next_size == remaining, false);

drivers/firmware/efi/apple-properties.c

56

int remaining = dev_header->len - (ptr - (void *)dev_header);

drivers/firmware/efi/apple-properties.c

61

if (sizeof(key_len) > remaining)

drivers/firmware/efi/apple-properties.c

65

if (key_len + sizeof(val_len) > remaining ||

drivers/firmware/efi/apple-properties.c

74

if (key_len + val_len > remaining ||

drivers/firmware/efi/test/efi_test.c

568

u64 max_storage, remaining, max_size;

drivers/firmware/efi/test/efi_test.c

577

&max_storage, &remaining, &max_size);

drivers/firmware/efi/test/efi_test.c

589

if (put_user(remaining,

drivers/firmware/tegra/bpmp-debugfs.c

196

int remaining, err, close_err;

drivers/firmware/tegra/bpmp-debugfs.c

209

remaining = len;

drivers/firmware/tegra/bpmp-debugfs.c

211

while (remaining > 0) {

drivers/firmware/tegra/bpmp-debugfs.c

220

if (resp.frd.readlen > remaining) {

drivers/firmware/tegra/bpmp-debugfs.c

228

remaining -= resp.frd.readlen;

drivers/firmware/tegra/bpmp-debugfs.c

261

size_t remaining;

drivers/firmware/tegra/bpmp-debugfs.c

275

remaining = sz_data;

drivers/firmware/tegra/bpmp-debugfs.c

277

while (remaining > 0) {

drivers/firmware/tegra/bpmp-debugfs.c

278

len = min(remaining, sizeof(req.fwr.data));

drivers/firmware/tegra/bpmp-debugfs.c

291

remaining -= req.fwr.datalen;

drivers/firmware/tegra/bpmp-debugfs.c

324

int remaining, err, close_err;

drivers/firmware/tegra/bpmp-debugfs.c

336

remaining = len;

drivers/firmware/tegra/bpmp-debugfs.c

338

while (remaining > 0) {

drivers/firmware/tegra/bpmp-debugfs.c

347

if (resp.frd.readlen > remaining) {

drivers/firmware/tegra/bpmp-debugfs.c

354

remaining -= resp.frd.readlen;

drivers/fpga/altera-cvp.c

431

size_t done, remaining, len;

drivers/fpga/altera-cvp.c

437

remaining = count;

drivers/fpga/altera-cvp.c

440

while (remaining) {

drivers/fpga/altera-cvp.c

451

len = min(conf->priv->block_size, remaining);

drivers/fpga/altera-cvp.c

455

remaining -= len;

drivers/fpga/xilinx-spi.c

28

size_t remaining, stride;

drivers/fpga/xilinx-spi.c

31

remaining = fw_data_end - fw_data;

drivers/fpga/xilinx-spi.c

32

stride = min_t(size_t, remaining, SZ_4K);

drivers/fsi/fsi-sbefifo.c

498

size_t len, chunk, vacant = 0, remaining = cmd_len;

drivers/fsi/fsi-sbefifo.c

508

while (remaining) {

drivers/fsi/fsi-sbefifo.c

516

len = chunk = min(vacant, remaining);

drivers/fsi/fsi-sbefifo.c

529

remaining -= chunk;

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

101

cur->remaining = size;

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

113

cur->remaining = size;

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

132

BUG_ON(size > cur->remaining);

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

134

cur->remaining -= size;

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

135

if (!cur->remaining)

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

153

cur->size = min(amdgpu_vram_mgr_block_size(block), cur->remaining);

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

162

cur->size = min(node->size << PAGE_SHIFT, cur->remaining);

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

39

uint64_t remaining;

drivers/gpu/drm/amd/amdgpu/amdgpu_res_cursor.h

89

cur->remaining = size;

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

1627

while (cursor.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

2511

while (cursor.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

2567

while (dst.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

317

while (src_mm.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c

465

while (cursor.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c

1172

while (cursor.remaining) {

drivers/gpu/drm/amd/amdgpu/amdgpu_vram_mgr.c

693

while (cursor.remaining) {

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

112

int i, remaining, current_count, buffer_offset, max_bytes, ret;

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

129

remaining = p->len;

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

139

while (remaining) {

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

140

if (remaining > max_bytes)

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

143

current_count = remaining;

drivers/gpu/drm/amd/amdgpu/atombios_i2c.c

149

remaining -= current_count;

drivers/gpu/drm/drm_gem.c

1627

unsigned long *remaining,

drivers/gpu/drm/drm_gem.c

1671

*remaining += obj->size >> PAGE_SHIFT;

drivers/gpu/drm/drm_modes.c

2035

int remaining, i;

drivers/gpu/drm/drm_modes.c

2051

remaining = length - (end_ptr - str_start);

drivers/gpu/drm/drm_modes.c

2052

if (remaining < 0)

drivers/gpu/drm/drm_modes.c

2055

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

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1217

unsigned long remaining;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1219

remaining = wait_for_completion_timeout(&gpu->event_free, timeout);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1221

if (!remaining) {

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1228

timeout = remaining;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1302

unsigned long remaining = etnaviv_timeout_to_jiffies(timeout);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1304

ret = dma_fence_wait_timeout(fence, true, remaining);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1329

unsigned long remaining;

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1335

remaining = etnaviv_timeout_to_jiffies(timeout);

drivers/gpu/drm/etnaviv/etnaviv_gpu.c

1339

remaining);

drivers/gpu/drm/i915/display/intel_pps.c

675

s64 panel_power_off_duration, remaining;

drivers/gpu/drm/i915/display/intel_pps.c

682

remaining = max(0, intel_dp->pps.panel_power_cycle_delay - panel_power_off_duration);

drivers/gpu/drm/i915/display/intel_pps.c

687

pps_name(intel_dp), remaining);

drivers/gpu/drm/i915/display/intel_pps.c

691

if (remaining)

drivers/gpu/drm/i915/display/intel_pps.c

692

wait_remaining_ms_from_jiffies(jiffies, remaining);

drivers/gpu/drm/imagination/pvr_cccb.c

111

u32 read_offset, remaining;

drivers/gpu/drm/imagination/pvr_cccb.c

115

remaining = pvr_cccb->size - pvr_cccb->write_offset;

drivers/gpu/drm/imagination/pvr_cccb.c

121

if (size + PADDING_COMMAND_SIZE > remaining)

drivers/gpu/drm/imagination/pvr_cccb.c

122

size += remaining;

drivers/gpu/drm/imagination/pvr_cccb.c

159

u32 remaining = pvr_cccb->size - pvr_cccb->write_offset;

drivers/gpu/drm/imagination/pvr_cccb.c

166

if (remaining < sz_with_hdr + PADDING_COMMAND_SIZE) {

drivers/gpu/drm/imagination/pvr_cccb.c

171

required_size = sz_with_hdr + remaining;

drivers/gpu/drm/imagination/pvr_cccb.c

185

.cmd_size = remaining - sizeof(pad_cmd),

drivers/gpu/drm/msm/adreno/adreno_device.c

364

int remaining, ret;

drivers/gpu/drm/msm/adreno/adreno_device.c

371

remaining = wait_event_timeout(gpu->retire_event,

drivers/gpu/drm/msm/adreno/adreno_device.c

374

if (remaining == 0) {

drivers/gpu/drm/msm/msm_gem_shrinker.c

174

unsigned long remaining;

drivers/gpu/drm/msm/msm_gem_shrinker.c

184

unsigned long remaining = 0;

drivers/gpu/drm/msm/msm_gem_shrinker.c

191

&stages[i].remaining,

drivers/gpu/drm/msm/msm_gem_shrinker.c

196

remaining += stages[i].remaining;

drivers/gpu/drm/msm/msm_gem_shrinker.c

205

return (freed > 0 && remaining > 0) ? freed : SHRINK_STOP;

drivers/gpu/drm/msm/msm_gem_shrinker.c

256

unsigned long remaining = 0;

drivers/gpu/drm/msm/msm_gem_shrinker.c

261

&remaining,

drivers/gpu/drm/msm/msm_gpu_trace.h

209

TP_PROTO(u32 count, u32 remaining),

drivers/gpu/drm/msm/msm_gpu_trace.h

210

TP_ARGS(count, remaining),

drivers/gpu/drm/msm/msm_gpu_trace.h

213

__field(u32, remaining)

drivers/gpu/drm/msm/msm_gpu_trace.h

217

__entry->remaining = remaining;

drivers/gpu/drm/msm/msm_gpu_trace.h

219

TP_printk("count=%u, remaining=%u", __entry->count, __entry->remaining)

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxch.c

42

u8 remaining = msg->len;

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxch.c

45

while (remaining) {

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxch.c

53

if (mcnt || remaining > 16)

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxch.c

59

cnt = min_t(u8, remaining, 16);

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxch.c

72

remaining -= cnt;

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bit.c

189

u8 remaining = msg->len;

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bit.c

197

while (!ret && remaining--)

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bit.c

198

ret = nvkm_i2c_get_byte(bus, ptr++, !remaining);

drivers/gpu/drm/nouveau/nvkm/subdev/i2c/bit.c

200

while (!ret && remaining--)

drivers/gpu/drm/panthor/panthor_sched.c

1092

return queue->timeout.remaining != MAX_SCHEDULE_TIMEOUT;

drivers/gpu/drm/panthor/panthor_sched.c

1141

queue->timeout.remaining = msecs_to_jiffies(JOB_TIMEOUT_MS);

drivers/gpu/drm/panthor/panthor_sched.c

1143

queue->timeout.remaining = qtimeout - now;

drivers/gpu/drm/panthor/panthor_sched.c

1145

queue->timeout.remaining = 0;

drivers/gpu/drm/panthor/panthor_sched.c

1147

if (WARN_ON_ONCE(queue->timeout.remaining > msecs_to_jiffies(JOB_TIMEOUT_MS)))

drivers/gpu/drm/panthor/panthor_sched.c

1148

queue->timeout.remaining = msecs_to_jiffies(JOB_TIMEOUT_MS);

drivers/gpu/drm/panthor/panthor_sched.c

1167

queue->timeout.remaining);

drivers/gpu/drm/panthor/panthor_sched.c

1169

queue->timeout.remaining = MAX_SCHEDULE_TIMEOUT;

drivers/gpu/drm/panthor/panthor_sched.c

3520

queue->timeout.remaining = msecs_to_jiffies(JOB_TIMEOUT_MS);

drivers/gpu/drm/panthor/panthor_sched.c

371

unsigned long remaining;

drivers/gpu/drm/radeon/atombios_i2c.c

105

int i, remaining, current_count, buffer_offset, max_bytes, ret;

drivers/gpu/drm/radeon/atombios_i2c.c

122

remaining = p->len;

drivers/gpu/drm/radeon/atombios_i2c.c

132

while (remaining) {

drivers/gpu/drm/radeon/atombios_i2c.c

133

if (remaining > max_bytes)

drivers/gpu/drm/radeon/atombios_i2c.c

136

current_count = remaining;

drivers/gpu/drm/radeon/atombios_i2c.c

142

remaining -= current_count;

drivers/gpu/drm/radeon/radeon_i2c.c

581

int i, j, remaining, current_count, buffer_offset, ret = num;

drivers/gpu/drm/radeon/radeon_i2c.c

700

remaining = p->len;

drivers/gpu/drm/radeon/radeon_i2c.c

703

while (remaining) {

drivers/gpu/drm/radeon/radeon_i2c.c

704

if (remaining > 15)

drivers/gpu/drm/radeon/radeon_i2c.c

707

current_count = remaining;

drivers/gpu/drm/radeon/radeon_i2c.c

739

remaining -= current_count;

drivers/gpu/drm/radeon/radeon_i2c.c

743

while (remaining) {

drivers/gpu/drm/radeon/radeon_i2c.c

744

if (remaining > 15)

drivers/gpu/drm/radeon/radeon_i2c.c

747

current_count = remaining;

drivers/gpu/drm/radeon/radeon_i2c.c

780

remaining -= current_count;

drivers/gpu/drm/scheduler/sched_main.c

488

unsigned long remaining)

drivers/gpu/drm/scheduler/sched_main.c

495

mod_delayed_work(sched->timeout_wq, &sched->work_tdr, remaining);

drivers/gpu/drm/xe/xe_ggtt.c

778

cur.remaining; xe_res_next(&cur, XE_PAGE_SIZE))

drivers/gpu/drm/xe/xe_ggtt.c

779

ggtt->pt_ops->ggtt_set_pte(ggtt, end - cur.remaining,

drivers/gpu/drm/xe/xe_ggtt.c

786

cur.remaining; xe_res_next(&cur, XE_PAGE_SIZE))

drivers/gpu/drm/xe/xe_ggtt.c

787

ggtt->pt_ops->ggtt_set_pte(ggtt, end - cur.remaining,

drivers/gpu/drm/xe/xe_gt_sriov_pf_migration.c

270

data->remaining = size;

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

290

struct reg_data *data, u32 *remaining)

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

311

*remaining = runtime->size - start - count;

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

322

u32 remaining = 0;

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

344

ret = pf_service_runtime_query(gt, start, limit, reg_data_buf, &remaining);

drivers/gpu/drm/xe/xe_gt_sriov_pf_service.c

351

response[1] = FIELD_PREP(VF2PF_QUERY_RUNTIME_RESPONSE_MSG_1_REMAINING, remaining);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

936

u32 count, remaining, num, i;

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

972

remaining = FIELD_GET(VF2PF_QUERY_RUNTIME_RESPONSE_MSG_1_REMAINING, response[1]);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

975

count, num, ret, start, remaining);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

983

ret = vf_prepare_runtime_info(gt, num + remaining);

drivers/gpu/drm/xe/xe_gt_sriov_vf.c

998

if (remaining) {

drivers/gpu/drm/xe/xe_lmtt.c

480

while (cur.remaining) {

drivers/gpu/drm/xe/xe_migrate.c

530

u64 size = min_t(u64, max_mem_transfer_per_pass(xe), cur->remaining);

drivers/gpu/drm/xe/xe_res_cursor.h

132

cur->remaining = size;

drivers/gpu/drm/xe/xe_res_cursor.h

145

cur->remaining = size;

drivers/gpu/drm/xe/xe_res_cursor.h

184

while (cur->dma_seg_size - start < cur->remaining) {

drivers/gpu/drm/xe/xe_res_cursor.h

214

cur->remaining = size;

drivers/gpu/drm/xe/xe_res_cursor.h

242

cur->remaining = size;

drivers/gpu/drm/xe/xe_res_cursor.h

266

XE_WARN_ON(size > cur->remaining);

drivers/gpu/drm/xe/xe_res_cursor.h

268

cur->remaining -= size;

drivers/gpu/drm/xe/xe_res_cursor.h

269

if (!cur->remaining)

drivers/gpu/drm/xe/xe_res_cursor.h

310

cur->remaining);

drivers/gpu/drm/xe/xe_res_cursor.h

51

u64 remaining;

drivers/gpu/drm/xe/xe_sriov_packet.c

175

data->remaining = size;

drivers/gpu/drm/xe/xe_sriov_packet.c

195

data->remaining = data->hdr.size;

drivers/gpu/drm/xe/xe_sriov_packet.c

222

if (len > data->remaining)

drivers/gpu/drm/xe/xe_sriov_packet.c

223

len = data->remaining;

drivers/gpu/drm/xe/xe_sriov_packet.c

225

if (copy_to_user(buf, data->vaddr + (data->hdr.size - data->remaining), len))

drivers/gpu/drm/xe/xe_sriov_packet.c

228

data->remaining -= len;

drivers/gpu/drm/xe/xe_sriov_packet.c

243

if ((*data)->remaining == 0 && (*data)->hdr_remaining == 0) {

drivers/gpu/drm/xe/xe_sriov_packet.c

301

if (len > data->remaining)

drivers/gpu/drm/xe/xe_sriov_packet.c

302

len = data->remaining;

drivers/gpu/drm/xe/xe_sriov_packet.c

304

if (copy_from_user(data->vaddr + (data->hdr.size - data->remaining), buf, len))

drivers/gpu/drm/xe/xe_sriov_packet.c

307

data->remaining -= len;

drivers/gpu/drm/xe/xe_sriov_packet.c

340

if ((*data)->hdr_remaining == 0 && (*data)->remaining == 0) {

drivers/gpu/drm/xe/xe_sriov_packet_types.h

62

size_t remaining;

drivers/gpu/drm/xe/xe_ttm_vram_mgr.c

380

while (cursor.remaining) {

drivers/hv/mshv_common.c

107

remaining -= completed;

drivers/hv/mshv_common.c

36

unsigned long remaining = count;

drivers/hv/mshv_common.c

52

while (remaining) {

drivers/hv/mshv_common.c

53

rep_count = min(remaining, HV_GET_REGISTER_BATCH_SIZE);

drivers/hv/mshv_common.c

67

remaining -= completed;

drivers/hv/mshv_common.c

81

unsigned long remaining = count;

drivers/hv/mshv_common.c

95

while (remaining) {

drivers/hv/mshv_common.c

96

rep_count = min(remaining, HV_SET_REGISTER_BATCH_SIZE);

drivers/hv/mshv_root_hv_call.c

342

unsigned long remaining = count;

drivers/hv/mshv_root_hv_call.c

348

while (remaining) {

drivers/hv/mshv_root_hv_call.c

356

rep_count = min(remaining, HV_GET_GPA_ACCESS_STATES_BATCH_SIZE);

drivers/hv/mshv_root_hv_call.c

371

remaining -= completed;

drivers/hv/mshv_root_hv_call.c

48

unsigned long remaining = count;

drivers/hv/mshv_root_hv_call.c

58

while (remaining) {

drivers/hv/mshv_root_hv_call.c

66

min(remaining, HV_WITHDRAW_BATCH_SIZE),

drivers/hv/mshv_root_hv_call.c

82

remaining -= completed;

drivers/hv/mshv_root_main.c

730

int remaining = page_count - completed;

drivers/hv/mshv_root_main.c

732

ret = pin_user_pages_fast(user_addr, remaining, FOLL_WRITE,

drivers/hwtracing/intel_th/msu.c

605

size_t remaining = 0;

drivers/hwtracing/intel_th/msu.c

637

remaining = fn(data, src, tocopy);

drivers/hwtracing/intel_th/msu.c

639

if (remaining)

drivers/hwtracing/intel_th/msu.c

642

copied = tocopy - remaining;

drivers/i2c/busses/i2c-imx-lpi2c.c

446

unsigned int temp, remaining;

drivers/i2c/busses/i2c-imx-lpi2c.c

448

remaining = lpi2c_imx->msglen - lpi2c_imx->delivered;

drivers/i2c/busses/i2c-imx-lpi2c.c

450

if (remaining > (lpi2c_imx->rxfifosize >> 1))

drivers/i2c/busses/i2c-imx-lpi2c.c

487

unsigned int remaining;

drivers/i2c/busses/i2c-imx-lpi2c.c

498

remaining = lpi2c_imx->msglen - lpi2c_imx->delivered;

drivers/i2c/busses/i2c-imx-lpi2c.c

500

if (!remaining) {

drivers/i2c/busses/i2c-imx-lpi2c.c

511

temp = (remaining > CHUNK_DATA ? CHUNK_DATA : remaining) - 1;

drivers/iio/imu/bno055/bno055_ser_core.c

386

size_t remaining = size;

drivers/iio/imu/bno055/bno055_ser_core.c

406

remaining--;

drivers/iio/imu/bno055/bno055_ser_core.c

416

if (remaining == 0)

drivers/iio/imu/bno055/bno055_ser_core.c

420

if (remaining > 1) {

drivers/iio/imu/bno055/bno055_ser_core.c

434

remaining--;

drivers/iio/imu/bno055/bno055_ser_core.c

441

if (remaining == 0)

drivers/iio/imu/bno055/bno055_ser_core.c

444

if (priv->rx.databuf_count + remaining > priv->rx.expected_len) {

drivers/iio/imu/bno055/bno055_ser_core.c

469

(priv->rx.databuf_count + remaining <= priv->expected_data_len))

drivers/iio/imu/bno055/bno055_ser_core.c

471

buf, remaining);

drivers/iio/imu/bno055/bno055_ser_core.c

474

priv->rx.databuf_count += remaining;

drivers/infiniband/core/cma.c

3752

int low, high, remaining;

drivers/infiniband/core/cma.c

3759

remaining = (high - low) + 1;

drivers/infiniband/core/cma.c

3760

rover = get_random_u32_inclusive(low, remaining + low - 1);

drivers/infiniband/core/cma.c

3784

if (--remaining) {

drivers/input/keyboard/applespi.c

1429

rem = le16_to_cpu(packet->remaining);

drivers/input/keyboard/applespi.c

350

__le16 remaining;

drivers/input/rmi4/rmi_f34v7.c

631

u16 remaining = block_cnt;

drivers/input/rmi4/rmi_f34v7.c

654

transfer = min(remaining, max_transfer);

drivers/input/rmi4/rmi_f34v7.c

663

__func__, remaining);

drivers/input/rmi4/rmi_f34v7.c

684

__func__, remaining);

drivers/input/rmi4/rmi_f34v7.c

689

remaining -= transfer;

drivers/input/rmi4/rmi_f34v7.c

690

} while (remaining);

drivers/input/rmi4/rmi_f34v7.c

704

u16 remaining = block_cnt;

drivers/input/rmi4/rmi_f34v7.c

728

transfer = min(remaining, max_transfer);

drivers/input/rmi4/rmi_f34v7.c

739

__func__, remaining);

drivers/input/rmi4/rmi_f34v7.c

753

__func__, remaining);

drivers/input/rmi4/rmi_f34v7.c

762

remaining -= transfer;

drivers/input/rmi4/rmi_f34v7.c

766

} while (remaining);

drivers/iommu/iommufd/iova_bitmap.c

304

unsigned long remaining, bytes;

drivers/iommu/iommufd/iova_bitmap.c

308

remaining = bitmap->mapped_total_index - bitmap->mapped_base_index;

drivers/iommu/iommufd/iova_bitmap.c

309

remaining = min_t(unsigned long, remaining,

drivers/iommu/iommufd/iova_bitmap.c

312

return remaining;

drivers/iommu/iommufd/iova_bitmap.c

322

unsigned long remaining;

drivers/iommu/iommufd/iova_bitmap.c

330

remaining = iova_bitmap_index_to_offset(bitmap,

drivers/iommu/iommufd/iova_bitmap.c

333

if (iova + remaining - 1 > max_iova)

drivers/iommu/iommufd/iova_bitmap.c

334

remaining -= ((iova + remaining - 1) - max_iova);

drivers/iommu/iommufd/iova_bitmap.c

336

return remaining;

drivers/mailbox/riscv-sbi-mpxy-mbox.c

101

__le32 remaining;

drivers/mailbox/riscv-sbi-mpxy-mbox.c

132

u32 remaining, returned;

drivers/mailbox/riscv-sbi-mpxy-mbox.c

148

remaining = le32_to_cpu(sdata->remaining);

drivers/mailbox/riscv-sbi-mpxy-mbox.c

150

*channel_count = remaining + returned;

drivers/mailbox/riscv-sbi-mpxy-mbox.c

161

u32 remaining, returned, count, start_index = 0;

drivers/mailbox/riscv-sbi-mpxy-mbox.c

177

remaining = le32_to_cpu(sdata->remaining);

drivers/mailbox/riscv-sbi-mpxy-mbox.c

184

} while (remaining && start_index < channel_count);

drivers/mailbox/riscv-sbi-mpxy-mbox.c

91

__le32 remaining;

drivers/md/dm-io.c

315

sector_t remaining = where->count;

drivers/md/dm-io.c

349

num_bvecs = bio_max_segs(dm_sector_div_up(remaining,

drivers/md/dm-io.c

355

bio->bi_iter.bi_sector = where->sector + (where->count - remaining);

drivers/md/dm-io.c

361

num_sectors = min_t(sector_t, special_cmd_max_sectors, remaining);

drivers/md/dm-io.c

363

remaining -= num_sectors;

drivers/md/dm-io.c

365

while (remaining) {

drivers/md/dm-io.c

370

len = min(len, to_bytes(remaining));

drivers/md/dm-io.c

375

remaining -= to_sector(len);

drivers/md/dm-io.c

382

WARN_ON_ONCE(opf & REQ_ATOMIC && remaining);

drivers/md/dm-io.c

383

} while (remaining);

drivers/md/dm-ioctl.c

1287

size_t remaining, len, used = 0;

drivers/md/dm-ioctl.c

1305

remaining = len - (outptr - outbuf);

drivers/md/dm-ioctl.c

1306

if (remaining <= sizeof(struct dm_target_spec)) {

drivers/md/dm-ioctl.c

1320

remaining = len - (outptr - outbuf);

drivers/md/dm-ioctl.c

1321

if (remaining <= 0) {

drivers/md/dm-ioctl.c

1330

ti->type->status(ti, type, status_flags, outptr, remaining);

drivers/md/dm-ioctl.c

1335

if (l == remaining) {

drivers/md/dm-ioctl.c

1427

size_t remaining = end - (char *)last;

drivers/md/dm-ioctl.c

1433

if (remaining - sizeof(struct dm_target_spec) <= next) {

drivers/md/dm-table.c

622

unsigned short remaining = 0;

drivers/md/dm-table.c

645

if (remaining < ti->len &&

drivers/md/dm-table.c

646

remaining & ((ti_limits.logical_block_size >>

drivers/md/dm-table.c

653

remaining = next_target_start ?

drivers/md/dm-table.c

657

if (remaining) {

drivers/md/dm-vdo/encodings.c

714

block_count_t flushing_threshold, remaining, blocking_threshold;

drivers/md/dm-vdo/encodings.c

744

remaining = slab_journal_blocks - flushing_threshold;

drivers/md/dm-vdo/encodings.c

745

blocking_threshold = flushing_threshold + ((remaining * 5) / 7);

drivers/md/dm-vdo/indexer/index.c

401

unsigned int remaining;

drivers/md/dm-vdo/indexer/index.c

403

remaining = uds_put_open_chapter(zone->open_chapter, &request->record_name,

drivers/md/dm-vdo/indexer/index.c

405

if (remaining == 0)

drivers/md/dm-vdo/indexer/open-chapter.c

392

unsigned int remaining;

drivers/md/dm-vdo/indexer/open-chapter.c

395

remaining = uds_put_open_chapter(open_chapter, &record.name,

drivers/md/dm-vdo/indexer/open-chapter.c

398

full_flags[zone] = (remaining <= 1);

drivers/md/dm-vdo/int-map.c

429

ptrdiff_t remaining = &map->buckets[map->bucket_count] - bucket;

drivers/md/dm-vdo/int-map.c

430

struct bucket *sentinel = &bucket[min_t(ptrdiff_t, remaining, max_probes)];

drivers/md/dm-vdo/repair.c

1701

block_count_t remaining = journal->size;

drivers/md/dm-vdo/repair.c

1702

block_count_t vio_count = DIV_ROUND_UP(remaining, MAX_BLOCKS_PER_VIO);

drivers/md/dm-vdo/repair.c

1732

result = vdo_allocate(remaining * VDO_BLOCK_SIZE, char, __func__,

drivers/md/dm-vdo/repair.c

1743

block_count_t blocks = min_t(block_count_t, remaining,

drivers/md/dm-vdo/repair.c

1754

remaining -= blocks;

drivers/md/dm-vdo/vio.c

207

int remaining;

drivers/md/dm-vdo/vio.c

223

remaining = size;

drivers/md/dm-vdo/vio.c

225

for (i = 0; (i < bvec_count) && (remaining > 0); i++) {

drivers/md/dm-vdo/vio.c

230

if (bytes > remaining)

drivers/md/dm-vdo/vio.c

231

bytes = remaining;

drivers/md/dm-vdo/vio.c

243

remaining -= bytes;

drivers/md/persistent-data/dm-array.c

1000

if (count < remaining) {

drivers/md/persistent-data/dm-array.c

1005

count -= remaining;

drivers/md/persistent-data/dm-array.c

1006

c->index += (remaining - 1);

drivers/md/persistent-data/dm-array.c

998

uint32_t remaining = le32_to_cpu(c->ab->nr_entries) - c->index;

drivers/md/raid1.c

1617

atomic_set(&r1_bio->remaining, 1);

drivers/md/raid1.c

1661

atomic_inc(&r1_bio->remaining);

drivers/md/raid1.c

2041

if (atomic_dec_and_test(&r1_bio->remaining))

drivers/md/raid1.c

2061

if (atomic_dec_and_test(&r1_bio->remaining)) {

drivers/md/raid1.c

2356

atomic_set(&r1_bio->remaining, 1);

drivers/md/raid1.c

2374

atomic_inc(&r1_bio->remaining);

drivers/md/raid1.c

3035

atomic_set(&r1_bio->remaining, read_targets);

drivers/md/raid1.c

3046

atomic_set(&r1_bio->remaining, 1);

drivers/md/raid1.c

432

if (!atomic_dec_and_test(&r1_bio->remaining))

drivers/md/raid1.c

532

if (atomic_read(&r1_bio->behind_remaining) >= (atomic_read(&r1_bio->remaining)-1) &&

drivers/md/raid1.h

127

atomic_t remaining; /* 'have we finished' count,

drivers/md/raid10.c

1278

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

1500

atomic_set(&r10_bio->remaining, 1);

drivers/md/raid10.c

1557

while (atomic_dec_and_test(&r10bio->remaining)) {

drivers/md/raid10.c

1779

atomic_set(&r10_bio->remaining, 1);

drivers/md/raid10.c

1824

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

1838

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

1851

atomic_inc(&first_r10bio->remaining);

drivers/md/raid10.c

2237

atomic_dec_and_test(&r10_bio->remaining)) {

drivers/md/raid10.c

2266

while (atomic_dec_and_test(&r10_bio->remaining)) {

drivers/md/raid10.c

2349

atomic_set(&r10_bio->remaining, 1);

drivers/md/raid10.c

2427

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

2445

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

2450

if (atomic_dec_and_test(&r10_bio->remaining)) {

drivers/md/raid10.c

3329

atomic_set(&r10_bio->remaining, 0);

drivers/md/raid10.c

3333

atomic_inc(&rb2->remaining);

drivers/md/raid10.c

3414

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

3435

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

3465

atomic_dec(&rb2->remaining);

drivers/md/raid10.c

3535

atomic_set(&r10_bio->remaining, 0);

drivers/md/raid10.c

3573

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

441

if (atomic_dec_and_test(&r10_bio->remaining)) {

drivers/md/raid10.c

4707

atomic_set(&r10_bio->remaining, 0);

drivers/md/raid10.c

4811

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

4855

atomic_set(&r10_bio->remaining, 1);

drivers/md/raid10.c

4871

atomic_inc(&r10_bio->remaining);

drivers/md/raid10.c

5004

if (!atomic_dec_and_test(&r10_bio->remaining))

drivers/md/raid10.h

115

atomic_t remaining; /* 'have we finished' count,

drivers/media/dvb-frontends/cx24116.c

555

int i, ret, len, max, remaining;

drivers/media/dvb-frontends/cx24116.c

599

for (remaining = fw->size; remaining > 0; remaining -= max - 1) {

drivers/media/dvb-frontends/cx24116.c

600

len = remaining;

drivers/media/dvb-frontends/cx24116.c

604

cx24116_writeregN(state, 0xF7, &fw->data[fw->size - remaining],

drivers/media/dvb-frontends/si2168.c

413

int ret, len, remaining;

drivers/media/dvb-frontends/si2168.c

462

for (remaining = fw->size; remaining > 0; remaining -= 17) {

drivers/media/dvb-frontends/si2168.c

463

len = fw->data[fw->size - remaining];

drivers/media/dvb-frontends/si2168.c

468

cmd_init(&cmd, &fw->data[(fw->size - remaining) + 1],

drivers/media/dvb-frontends/si2168.c

476

for (remaining = fw->size; remaining > 0; remaining -= 8) {

drivers/media/dvb-frontends/si2168.c

477

cmd_init(&cmd, &fw->data[fw->size - remaining], 8, 1);

drivers/media/dvb-frontends/tda10071.c

756

int ret, i, len, remaining, fw_size;

drivers/media/dvb-frontends/tda10071.c

882

for (remaining = fw_size; remaining > 0;

drivers/media/dvb-frontends/tda10071.c

883

remaining -= (dev->i2c_wr_max - 1)) {

drivers/media/dvb-frontends/tda10071.c

884

len = remaining;

drivers/media/dvb-frontends/tda10071.c

889

(u8 *) &fw->data[fw_size - remaining], len);

drivers/media/pci/cx18/cx18-ioctl.c

713

int consumed, remaining;

drivers/media/pci/cx18/cx18-ioctl.c

728

remaining = buf->bytesused - buf->readpos;

drivers/media/pci/cx18/cx18-ioctl.c

733

while (remaining >= sizeof(struct cx18_enc_idx_entry) &&

drivers/media/pci/cx18/cx18-ioctl.c

753

remaining -= sizeof(struct cx18_enc_idx_entry);

drivers/media/pci/cx18/cx18-ioctl.c

758

if (remaining > 0 && remaining < sizeof(struct cx18_enc_idx_entry))

drivers/media/pci/cx18/cx18-ioctl.c

759

consumed += remaining;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

197

int remaining, i;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

200

remaining = length + entry[0].first_entry.first_page_offset;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

201

entry[1].second_entry.num_of_pages = PFN_UP(remaining);

drivers/media/pci/intel/ipu3/ipu3-cio2.c

210

remaining = offset_in_page(remaining) ?: PAGE_SIZE;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

211

entry[1].second_entry.last_page_available_bytes = remaining - 1;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

213

remaining = length;

drivers/media/pci/intel/ipu3/ipu3-cio2.c

215

while (remaining > 0) {

drivers/media/pci/intel/ipu3/ipu3-cio2.c

217

remaining -= CIO2_LOP_ENTRIES * PAGE_SIZE;

drivers/media/platform/chips-media/coda/coda-bit.c

781

if (size > iram->remaining)

drivers/media/platform/chips-media/coda/coda-bit.c

783

iram->remaining -= size;

drivers/media/platform/chips-media/coda/coda-bit.c

804

iram_info->remaining = dev->iram.size;

drivers/media/platform/chips-media/coda/coda.h

194

int remaining;

drivers/media/test-drivers/vicodec/vicodec-core.c

648

u32 remaining = sz - ctx->cur_buf_offset - sizeof(*p_hdr);

drivers/media/test-drivers/vicodec/vicodec-core.c

651

ctx->comp_has_next_frame = remaining >= frame_size;

drivers/media/tuners/si2157.c

116

for (remaining = fw->size; remaining > 0; remaining -= 17) {

drivers/media/tuners/si2157.c

117

len = fw->data[fw->size - remaining];

drivers/media/tuners/si2157.c

123

memcpy(cmd.args, &fw->data[(fw->size - remaining) + 1], len);

drivers/media/tuners/si2157.c

97

int ret, len, remaining;

drivers/media/tuners/tda18218.c

16

int ret = 0, len2, remaining;

drivers/media/tuners/tda18218.c

33

for (remaining = len; remaining > 0;

drivers/media/tuners/tda18218.c

34

remaining -= (priv->cfg->i2c_wr_max - 1)) {

drivers/media/tuners/tda18218.c

35

len2 = remaining;

drivers/media/tuners/tda18218.c

40

buf[0] = reg + len - remaining;

drivers/media/tuners/tda18218.c

41

memcpy(&buf[1], &val[len - remaining], len2);

drivers/media/usb/dvb-usb-v2/ec168.c

212

int ret, len, remaining;

drivers/media/usb/dvb-usb-v2/ec168.c

217

for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {

drivers/media/usb/dvb-usb-v2/ec168.c

218

len = remaining;

drivers/media/usb/dvb-usb-v2/ec168.c

223

req.data = (u8 *) &fw->data[fw->size - remaining];

drivers/media/usb/dvb-usb-v2/ec168.c

224

req.index = fw->size - remaining;

drivers/message/fusion/mptlan.c

1103

if (remaining == 0)

drivers/message/fusion/mptlan.c

1108

else if (remaining < 10)

drivers/message/fusion/mptlan.c

1112

remaining, atomic_read(&priv->buckets_out));

drivers/message/fusion/mptlan.c

1114

if ((remaining < priv->bucketthresh) &&

drivers/message/fusion/mptlan.c

1115

((atomic_read(&priv->buckets_out) - remaining) >

drivers/message/fusion/mptlan.c

964

u32 remaining = le32_to_cpu(pRecvRep->BucketsRemaining);

drivers/misc/lkdtm/bugs.c

51

static int noinline recursive_loop(int remaining)

drivers/misc/lkdtm/bugs.c

56

memset((void *)buf, remaining & 0xFF, sizeof(buf));

drivers/misc/lkdtm/bugs.c

57

if (!remaining)

drivers/misc/lkdtm/bugs.c

60

ret = recursive_loop((int)buf[remaining % sizeof(buf)] - 1);

drivers/mmc/host/atmel-mci.c

1977

unsigned int remaining = sg->length - offset;

drivers/mmc/host/atmel-mci.c

1979

sg_pcopy_from_buffer(sg, 1, &value, remaining, offset);

drivers/mmc/host/atmel-mci.c

1980

nbytes += remaining;

drivers/mmc/host/atmel-mci.c

1988

offset = 4 - remaining;

drivers/mmc/host/atmel-mci.c

1989

sg_pcopy_from_buffer(sg, 1, (u8 *)&value + remaining,

drivers/mmc/host/atmel-mci.c

2042

unsigned int remaining = sg->length - offset;

drivers/mmc/host/atmel-mci.c

2045

sg_pcopy_to_buffer(sg, 1, &value, remaining, offset);

drivers/mmc/host/atmel-mci.c

2046

nbytes += remaining;

drivers/mmc/host/atmel-mci.c

2055

offset = 4 - remaining;

drivers/mmc/host/atmel-mci.c

2056

sg_pcopy_to_buffer(sg, 1, (u8 *)&value + remaining,

drivers/mtd/devices/mtd_dataflash.c

307

size_t remaining = len;

drivers/mtd/devices/mtd_dataflash.c

329

while (remaining > 0) {

drivers/mtd/devices/mtd_dataflash.c

414

remaining = 0;

drivers/mtd/devices/mtd_dataflash.c

422

remaining = remaining - writelen;

drivers/mtd/devices/mtd_dataflash.c

428

if (remaining > priv->page_size)

drivers/mtd/devices/mtd_dataflash.c

431

writelen = remaining;

drivers/mtd/devices/st_spi_fsm.c

750

uint32_t remaining = size >> 2;

drivers/mtd/devices/st_spi_fsm.c

758

while (remaining) {

drivers/mtd/devices/st_spi_fsm.c

765

words = min(avail, remaining);

drivers/mtd/devices/st_spi_fsm.c

766

remaining -= words;

drivers/mtd/nand/raw/rockchip-nand-controller.c

335

unsigned int i, j, remaining, start;

drivers/mtd/nand/raw/rockchip-nand-controller.c

352

remaining = nand_subop_get_num_addr_cyc(subop, i);

drivers/mtd/nand/raw/rockchip-nand-controller.c

355

for (j = 0; j < 8 && j + start < remaining; j++)

drivers/mtd/nand/raw/sunxi_nand.c

1948

unsigned int i, j, remaining, start;

drivers/mtd/nand/raw/sunxi_nand.c

1970

remaining = nand_subop_get_num_addr_cyc(subop, i);

drivers/mtd/nand/raw/sunxi_nand.c

1972

for (j = 0; j < 8 && j + start < remaining; j++) {

drivers/mtd/nand/raw/sunxi_nand.c

1986

remaining = nand_subop_get_data_len(subop, i);

drivers/mtd/nand/raw/sunxi_nand.c

1987

cnt = min_t(u32, remaining, nfc->caps->sram_size);

drivers/mux/core.c

335

s64 remaining;

drivers/mux/core.c

341

remaining = ktime_us_delta(delayend, ktime_get());

drivers/mux/core.c

342

if (remaining > 0)

drivers/mux/core.c

343

fsleep(remaining);

drivers/net/ethernet/3com/typhoon.c

1275

u32 remaining;

drivers/net/ethernet/3com/typhoon.c

1289

remaining = typhoon_fw->size;

drivers/net/ethernet/3com/typhoon.c

1290

if (remaining < sizeof(struct typhoon_file_header))

drivers/net/ethernet/3com/typhoon.c

1299

remaining -= sizeof(struct typhoon_file_header);

drivers/net/ethernet/3com/typhoon.c

1302

if (remaining < sizeof(struct typhoon_section_header))

drivers/net/ethernet/3com/typhoon.c

1309

if (remaining < section_len)

drivers/net/ethernet/3com/typhoon.c

1313

remaining -= section_len;

drivers/net/ethernet/amd/pds_core/adminq.c

233

unsigned long remaining;

drivers/net/ethernet/amd/pds_core/adminq.c

256

remaining = wait_for_completion_timeout(wc, poll_jiffies);

drivers/net/ethernet/amd/pds_core/adminq.c

257

if (remaining)

drivers/net/ethernet/amd/pds_core/adminq.c

295

if (remaining && comp->status)

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1819

int remaining = 0;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1824

remaining = 0;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1830

remaining = tls_rec_offset - prior_data_len;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1842

while (remaining > 0) {

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1844

if (remaining < frag_size)

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1847

remaining -= frag_size;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1851

frag_delta = skb_frag_size(f) - remaining;

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1855

skb_frag_off(f) + remaining,

drivers/net/ethernet/chelsio/inline_crypto/ch_ktls/chcr_ktls.c

1859

skb_frag_off(f) + remaining,

drivers/net/ethernet/emulex/benet/be_main.c

2329

u16 hdr_len, curr_frag_len, remaining;

drivers/net/ethernet/emulex/benet/be_main.c

2366

remaining = rxcp->pkt_size - curr_frag_len;

drivers/net/ethernet/emulex/benet/be_main.c

2369

curr_frag_len = min(remaining, rx_frag_size);

drivers/net/ethernet/emulex/benet/be_main.c

2389

remaining -= curr_frag_len;

drivers/net/ethernet/emulex/benet/be_main.c

2439

u16 remaining, curr_frag_len;

drivers/net/ethernet/emulex/benet/be_main.c

2448

remaining = rxcp->pkt_size;

drivers/net/ethernet/emulex/benet/be_main.c

2452

curr_frag_len = min(remaining, rx_frag_size);

drivers/net/ethernet/emulex/benet/be_main.c

2469

remaining -= curr_frag_len;

drivers/net/ethernet/fungible/funcore/fun_queue.c

236

u32 bufoff, total_len, remaining, fragsize, dataoff;

drivers/net/ethernet/fungible/funcore/fun_queue.c

267

for (remaining = total_len; remaining; remaining -= fragsize) {

drivers/net/ethernet/fungible/funcore/fun_queue.c

269

fragsize = min_t(unsigned int, PAGE_SIZE, remaining);

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

119

u32 idx, remaining;

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

124

*first_part_wqebbs = get_q_element(&wq->qpages, idx, &remaining);

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

125

if (likely(remaining >= num_wqebbs)) {

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

129

*first_part_wqebbs_num = remaining;

drivers/net/ethernet/huawei/hinic3/hinic3_wq.c

130

idx += remaining;

drivers/net/ethernet/ibm/ibmveth.c

215

u32 remaining = pool->size - atomic_read(&pool->available);

drivers/net/ethernet/ibm/ibmveth.c

232

while (remaining > 0) {

drivers/net/ethernet/ibm/ibmveth.c

236

for (filled = 0; filled < min(remaining, batch); filled++) {

drivers/net/ethernet/ibm/ibmveth.c

332

remaining -= filled;

drivers/net/ethernet/intel/e1000e/manage.c

187

u16 remaining, i, j, prev_bytes;

drivers/net/ethernet/intel/e1000e/manage.c

209

remaining = length & 0x3;

drivers/net/ethernet/intel/e1000e/manage.c

210

length -= remaining;

drivers/net/ethernet/intel/e1000e/manage.c

226

if (remaining) {

drivers/net/ethernet/intel/e1000e/manage.c

228

if (j < remaining)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

628

int remaining, i = 0;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

659

remaining = info->sync_len;

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

660

while (remaining > 0) {

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

664

remaining -= skb_frag_size(frag);

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

668

if (remaining < 0)

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_tx.c

669

skb_frag_size_add(&info->frags[i - 1], remaining);

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

460

int remaining = wqe_bulk;

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

470

refill = min_t(u16, rq->wqe.info.refill_unit, remaining);

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

478

remaining -= refill;

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

479

} while (remaining);

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

124

long long remaining = data_length;

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

130

while (remaining >= sizeof(*tl)) {

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

135

if (be32_to_cpu(tl->length) > remaining - sizeof(*tl))

drivers/net/ethernet/netronome/nfp/nfp_net_debugdump.c

145

remaining -= total_tlv_size;

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

420

unsigned long remaining;

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

436

remaining = wait_for_completion_timeout(&ctx->work,

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

440

if (remaining)

drivers/net/ethernet/rocker/rocker_tlv.h

30

int *remaining)

drivers/net/ethernet/rocker/rocker_tlv.h

34

*remaining -= totlen;

drivers/net/ethernet/rocker/rocker_tlv.h

38

static inline int rocker_tlv_ok(const struct rocker_tlv *tlv, int remaining)

drivers/net/ethernet/rocker/rocker_tlv.h

40

return remaining >= (int) ROCKER_TLV_HDRLEN &&

drivers/net/ethernet/rocker/rocker_tlv.h

42

tlv->len <= remaining;

drivers/net/ethernet/sfc/efx_reflash.c

364

size_t remaining = data_size - offset;

drivers/net/ethernet/sfc/efx_reflash.c

372

chunk = roundup(remaining, align);

drivers/net/ethernet/sfc/efx_reflash.c

377

memcpy(buf, data + offset, remaining);

drivers/net/ethernet/sfc/efx_reflash.c

378

memset(buf + remaining, 0xFF, chunk - remaining);

drivers/net/ethernet/ti/icssm/icssm_prueth.c

587

int remaining;

drivers/net/ethernet/ti/icssm/icssm_prueth.c

602

remaining = pktlen - bytes;

drivers/net/ethernet/ti/icssm/icssm_prueth.c

604

memcpy(dst_addr, src_addr, remaining);

drivers/net/ethernet/ti/icssm/icssm_prueth.c

714

int remaining;

drivers/net/ethernet/ti/icssm/icssm_prueth.c

728

remaining = actual_pkt_len - bytes;

drivers/net/ethernet/ti/icssm/icssm_prueth.c

731

memcpy(dst_addr, src_addr, remaining);

drivers/net/ethernet/ti/icssm/icssm_prueth.c

732

src_addr += remaining;

drivers/net/usb/asix.h

174

u16 remaining;

drivers/net/usb/asix_common.c

131

rx->remaining = 0;

drivers/net/usb/asix_common.c

151

if (rx->remaining && (rx->remaining + sizeof(u32) <= skb->len)) {

drivers/net/usb/asix_common.c

152

offset = ((rx->remaining + 1) & 0xfffe);

drivers/net/usb/asix_common.c

159

rx->remaining);

drivers/net/usb/asix_common.c

167

if (!rx->remaining) {

drivers/net/usb/asix_common.c

209

rx->remaining = size;

drivers/net/usb/asix_common.c

212

if (rx->remaining > skb->len - offset) {

drivers/net/usb/asix_common.c

214

rx->remaining -= copy_length;

drivers/net/usb/asix_common.c

216

copy_length = rx->remaining;

drivers/net/usb/asix_common.c

217

rx->remaining = 0;

drivers/net/usb/asix_common.c

223

if (!rx->remaining) {

drivers/net/wireless/ath/ath10k/qmi.c

243

unsigned int remaining;

drivers/net/wireless/ath/ath10k/qmi.c

253

remaining = ar->normal_mode_fw.board_len;

drivers/net/wireless/ath/ath10k/qmi.c

255

while (remaining) {

drivers/net/wireless/ath/ath10k/qmi.c

265

if (remaining > QMI_WLFW_MAX_DATA_SIZE_V01) {

drivers/net/wireless/ath/ath10k/qmi.c

268

req->data_len = remaining;

drivers/net/wireless/ath/ath10k/qmi.c

309

remaining -= req->data_len;

drivers/net/wireless/ath/ath11k/qmi.c

2307

u32 remaining = len;

drivers/net/wireless/ath/ath11k/qmi.c

2324

while (remaining) {

drivers/net/wireless/ath/ath11k/qmi.c

2329

req->total_size = remaining;

drivers/net/wireless/ath/ath11k/qmi.c

2337

if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {

drivers/net/wireless/ath/ath11k/qmi.c

2340

req->data_len = remaining;

drivers/net/wireless/ath/ath11k/qmi.c

2394

remaining = 0;

drivers/net/wireless/ath/ath11k/qmi.c

2396

remaining -= req->data_len;

drivers/net/wireless/ath/ath11k/qmi.c

2400

remaining);

drivers/net/wireless/ath/ath12k/qmi.c

2969

u32 remaining = len;

drivers/net/wireless/ath/ath12k/qmi.c

2975

while (remaining) {

drivers/net/wireless/ath/ath12k/qmi.c

2980

req->total_size = remaining;

drivers/net/wireless/ath/ath12k/qmi.c

2988

if (remaining > QMI_WLANFW_MAX_DATA_SIZE_V01) {

drivers/net/wireless/ath/ath12k/qmi.c

2991

req->data_len = remaining;

drivers/net/wireless/ath/ath12k/qmi.c

3033

remaining = 0;

drivers/net/wireless/ath/ath12k/qmi.c

3035

remaining -= req->data_len;

drivers/net/wireless/ath/ath12k/qmi.c

3040

remaining);

drivers/net/wireless/intel/iwlwifi/fw/paging.c

174

int remaining = image->sec[sec_idx].len - offset;

drivers/net/wireless/intel/iwlwifi/fw/paging.c

182

len = remaining;

drivers/net/wireless/intel/iwlwifi/fw/paging.c

183

if (remaining !=

drivers/net/wireless/intel/iwlwifi/fw/paging.c

187

remaining);

drivers/net/wireless/intel/iwlwifi/fw/paging.c

191

} else if (block->fw_paging_size > remaining) {

drivers/net/wireless/intel/iwlwifi/fw/paging.c

194

idx, remaining);

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4074

int remaining = cnt;

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4085

if (n_queued > remaining) {

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4087

remaining = 0;

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4090

remaining -= n_queued;

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4092

sleep_tx_count = cnt - remaining;

drivers/net/wireless/intel/iwlwifi/mvm/sta.c

4098

if (WARN_ON(cnt - remaining == 0)) {

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

906

u32 remaining = fw_size;

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

951

size = (remaining > blksize) ? blksize : remaining;

drivers/net/wireless/quantenna/qtnfmac/pcie/topaz_pcie.c

969

remaining = (remaining < size) ? remaining : (remaining - size);

drivers/net/wwan/iosm/iosm_ipc_coredump.c

22

s32 remaining;

drivers/net/wwan/iosm/iosm_ipc_coredump.c

29

remaining = devlink->cd_file_info[entry].actual_size;

drivers/net/wwan/iosm/iosm_ipc_coredump.c

35

while (remaining > 0) {

drivers/net/wwan/iosm/iosm_ipc_coredump.c

36

bytes_to_read = min(remaining, MAX_DATA_SIZE);

drivers/net/wwan/iosm/iosm_ipc_coredump.c

44

remaining -= bytes_read;

drivers/nvdimm/badrange.c

199

u64 remaining = num_sectors;

drivers/nvdimm/badrange.c

202

while (remaining) {

drivers/nvdimm/badrange.c

203

int done = min_t(u64, remaining, INT_MAX);

drivers/nvdimm/badrange.c

206

remaining -= done;

drivers/nvdimm/btt.c

850

size_t remaining = btt->rawsize;

drivers/nvdimm/btt.c

859

while (remaining) {

drivers/nvdimm/btt.c

871

if (remaining == btt->rawsize) {

drivers/nvdimm/btt.c

907

remaining -= arena->size;

drivers/nvdimm/btt.c

929

size_t remaining = btt->rawsize;

drivers/nvdimm/btt.c

932

while (remaining) {

drivers/nvdimm/btt.c

934

size_t arena_size = min_t(u64, ARENA_MAX_SIZE, remaining);

drivers/nvdimm/btt.c

936

remaining -= arena_size;

drivers/nvdimm/btt.c

946

if (remaining >= ARENA_MIN_SIZE)

drivers/pci/controller/pcie-mediatek-gen3.c

320

resource_size_t remaining = size;

drivers/pci/controller/pcie-mediatek-gen3.c

327

while (remaining && (*num < PCIE_MAX_TRANS_TABLES)) {

drivers/pci/controller/pcie-mediatek-gen3.c

329

table_size = BIT(fls(remaining) - 1);

drivers/pci/controller/pcie-mediatek-gen3.c

366

remaining -= table_size;

drivers/pci/controller/pcie-mediatek-gen3.c

370

if (remaining)

drivers/pci/vgaarb.c

1135

size_t remaining = count;

drivers/pci/vgaarb.c

1149

remaining -= 5;

drivers/pci/vgaarb.c

1153

if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {

drivers/pci/vgaarb.c

1185

remaining -= 7;

drivers/pci/vgaarb.c

1193

(curr_pos, remaining, &io_state)) {

drivers/pci/vgaarb.c

1241

remaining -= 8;

drivers/pci/vgaarb.c

1245

if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {

drivers/pci/vgaarb.c

1285

remaining -= 7;

drivers/pci/vgaarb.c

1291

if (!vga_pci_str_to_vars(curr_pos, remaining,

drivers/pci/vgaarb.c

1349

remaining -= 8;

drivers/pci/vgaarb.c

1352

if (!vga_str_to_iostate(curr_pos, remaining, &io_state)) {

drivers/platform/x86/dell/dell-wmi-base.c

417

static int dell_wmi_process_key(struct wmi_device *wdev, int type, int code, u16 *buffer, int remaining)

drivers/platform/x86/dell/dell-wmi-base.c

446

} else if (type == 0x0011 && code == 0xe070 && remaining > 0) {

drivers/platform/x86/dell/dell-wmi-base.c

451

} else if (type == 0x0012 && code == 0x000c && remaining > 0) {

drivers/platform/x86/dell/dell-wmi-base.c

456

} else if (type == 0x0012 && code == 0x000d && remaining > 0) {

drivers/regulator/core.c

2987

s64 remaining = ktime_us_delta(end, ktime_get_boottime());

drivers/regulator/core.c

2989

if (remaining > 0)

drivers/regulator/core.c

2990

fsleep(remaining);

drivers/s390/char/sclp.c

925

u16 remaining;

drivers/s390/char/sclp.c

929

remaining = sccb->length - sizeof(struct sccb_header);

drivers/s390/char/sclp.c

930

while (remaining > 0) {

drivers/s390/char/sclp.c

931

remaining -= evbuf->length;

drivers/s390/char/sclp.c

935

remaining);

drivers/s390/char/vmlogrdr.c

468

priv->remaining = user_data_count;

drivers/s390/char/vmlogrdr.c

491

if (count > priv->remaining)

drivers/s390/char/vmlogrdr.c

492

count = priv->remaining;

drivers/s390/char/vmlogrdr.c

499

priv->remaining -= count;

drivers/s390/char/vmlogrdr.c

502

if (priv->remaining == 0)

drivers/s390/char/vmlogrdr.c

74

int remaining;

drivers/scsi/libfc/fc_fcp.c

598

size_t remaining;

drivers/scsi/libfc/fc_fcp.c

639

remaining = seq_blen;

drivers/scsi/libfc/fc_fcp.c

648

while (remaining > 0 && sg) {

drivers/scsi/libfc/fc_fcp.c

655

tlen = min(t_blen, remaining);

drivers/scsi/libfc/fc_fcp.c

700

remaining -= sg_bytes;

drivers/scsi/libfc/fc_fcp.c

710

if (remaining == 0)

drivers/scsi/libfc/fc_libfc.c

104

size_t remaining = len;

drivers/scsi/libfc/fc_libfc.c

107

while (remaining > 0 && sg) {

drivers/scsi/libfc/fc_libfc.c

123

sg_bytes = min(remaining, sg->length - *offset);

drivers/scsi/libfc/fc_libfc.c

139

remaining -= sg_bytes;

drivers/scsi/myrb.c

2242

unsigned int ldev_size = 0, remaining = 0;

drivers/scsi/myrb.c

2250

remaining = rbld_buf.blocks_left;

drivers/scsi/myrb.c

2253

if (remaining && ldev_size)

drivers/scsi/myrb.c

2254

percent_complete = (ldev_size - remaining) * 100 / ldev_size;

drivers/spi/spi-at91-usart.c

286

unsigned int remaining = aus->current_tx_remaining_bytes;

drivers/spi/spi-at91-usart.c

289

if (!remaining)

drivers/spi/spi-at91-usart.c

293

at91_usart_spi_writeb(aus, THR, tx_buf[len - remaining]);

drivers/spi/spi-at91-usart.c

301

int remaining = aus->current_rx_remaining_bytes;

drivers/spi/spi-at91-usart.c

304

if (!remaining)

drivers/spi/spi-at91-usart.c

307

rx_buf[len - remaining] = at91_usart_spi_readb(aus, RHR);

drivers/spi/spi-cadence-quadspi.c

1081

unsigned int remaining = n_tx;

drivers/spi/spi-cadence-quadspi.c

1089

writel(remaining, reg_base + CQSPI_REG_INDIRECTWRBYTES);

drivers/spi/spi-cadence-quadspi.c

1118

while (remaining > 0) {

drivers/spi/spi-cadence-quadspi.c

1121

write_bytes = remaining;

drivers/spi/spi-cadence-quadspi.c

1144

remaining -= write_bytes;

drivers/spi/spi-cadence-quadspi.c

1146

if (remaining > 0)

drivers/spi/spi-cadence-quadspi.c

742

unsigned int remaining = n_rx;

drivers/spi/spi-cadence-quadspi.c

752

writel(remaining, reg_base + CQSPI_REG_INDIRECTRDBYTES);

drivers/spi/spi-cadence-quadspi.c

777

while (remaining > 0) {

drivers/spi/spi-cadence-quadspi.c

800

unsigned int word_remain = round_down(remaining, 4);

drivers/spi/spi-cadence-quadspi.c

803

bytes_to_read = bytes_to_read > remaining ?

drivers/spi/spi-cadence-quadspi.c

804

remaining : bytes_to_read;

drivers/spi/spi-cadence-quadspi.c

819

remaining -= bytes_to_read;

drivers/spi/spi-dln2.c

552

u16 remaining = data_len;

drivers/spi/spi-dln2.c

556

if (remaining > DLN2_SPI_MAX_XFER_SIZE) {

drivers/spi/spi-dln2.c

560

len = remaining;

drivers/spi/spi-dln2.c

564

offset = data_len - remaining;

drivers/spi/spi-dln2.c

586

remaining -= len;

drivers/spi/spi-dln2.c

587

} while (remaining);

drivers/spi/spi-ljca.c

162

int remaining = len;

drivers/spi/spi-ljca.c

175

for (i = 0; remaining > 0; i++) {

drivers/spi/spi-ljca.c

176

cur_len = min_t(unsigned int, remaining, LJCA_SPI_MAX_XFER_SIZE);

drivers/spi/spi-ljca.c

177

complete = (cur_len == remaining);

drivers/spi/spi-ljca.c

187

remaining -= cur_len;

drivers/spi/spi-nxp-fspi.c

920

int remaining = op->data.nbytes - i;

drivers/spi/spi-nxp-fspi.c

927

for (j = 0; j < ALIGN(remaining, 4); j += 4) {

drivers/spi/spi-nxp-fspi.c

928

memcpy(&data, buf + i + j, min_t(int, 4, remaining - j));

drivers/target/tcm_fc/tfc_io.c

100

mem_len = min((size_t)sg->length, remaining);

drivers/target/tcm_fc/tfc_io.c

112

frame_len = min(frame_len, remaining);

drivers/target/tcm_fc/tfc_io.c

154

remaining -= tlen;

drivers/target/tcm_fc/tfc_io.c

159

if (!remaining)

drivers/target/tcm_fc/tfc_io.c

169

remaining, lport->lso_max);

drivers/target/tcm_fc/tfc_io.c

48

size_t remaining;

drivers/target/tcm_fc/tfc_io.c

74

remaining = se_cmd->data_length;

drivers/target/tcm_fc/tfc_io.c

79

BUG_ON(remaining && !se_cmd->t_data_sg);

drivers/target/tcm_fc/tfc_io.c

80

if (remaining) {

drivers/target/tcm_fc/tfc_io.c

88

use_sg = !(remaining % 4);

drivers/target/tcm_fc/tfc_io.c

90

while (remaining) {

drivers/tty/hvc/hvsi.c

170

int remaining = (int)(hp->inbuf_end - read_to);

drivers/tty/hvc/hvsi.c

172

pr_debug("%s: %i chars remain\n", __func__, remaining);

drivers/tty/hvc/hvsi.c

175

memmove(hp->inbuf, read_to, remaining);

drivers/tty/hvc/hvsi.c

177

hp->inbuf_end = hp->inbuf + remaining;

drivers/tty/serial/qcom_geni_serial.c

943

unsigned int tx_bytes, remaining = chunk;

drivers/tty/serial/qcom_geni_serial.c

946

while (remaining) {

drivers/tty/serial/qcom_geni_serial.c

948

tx_bytes = min(remaining, BYTES_PER_FIFO_WORD);

drivers/tty/serial/qcom_geni_serial.c

954

remaining -= tx_bytes;

drivers/usb/c67x00/c67x00-sched.c

647

int remaining;

drivers/usb/c67x00/c67x00-sched.c

656

remaining = urb->transfer_buffer_length - urb->actual_length;

drivers/usb/c67x00/c67x00-sched.c

661

usb_pipeout(urb->pipe) && !(remaining % maxps);

drivers/usb/c67x00/c67x00-sched.c

663

while (remaining || need_empty) {

drivers/usb/c67x00/c67x00-sched.c

667

len = (remaining > maxps) ? maxps : remaining;

drivers/usb/c67x00/c67x00-sched.c

673

remaining;

drivers/usb/c67x00/c67x00-sched.c

680

remaining -= len;

drivers/usb/c67x00/c67x00-sched.c

860

int maxps, need_empty, remaining;

drivers/usb/c67x00/c67x00-sched.c

874

remaining = urb->transfer_buffer_length - urb->actual_length;

drivers/usb/c67x00/c67x00-sched.c

876

usb_pipeout(urb->pipe) && !(remaining % maxps);

drivers/usb/c67x00/c67x00-sched.c

878

if (unlikely(!remaining && !need_empty))

drivers/usb/cdns3/cdnsp-ring.c

1005

u32 remaining;

drivers/usb/cdns3/cdnsp-ring.c

1010

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/cdns3/cdnsp-ring.c

1019

td->preq->request.actual = td->preq->request.length - remaining;

drivers/usb/cdns3/cdnsp-ring.c

1053

u32 remaining, requested, ep_trb_len;

drivers/usb/cdns3/cdnsp-ring.c

1061

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/cdns3/cdnsp-ring.c

1085

requested = remaining;

drivers/usb/cdns3/cdnsp-ring.c

1089

remaining = 0;

drivers/usb/cdns3/cdnsp-ring.c

1099

td_length += ep_trb_len - remaining;

drivers/usb/cdns3/cdnsp-ring.c

1140

u32 remaining, requested, ep_trb_len;

drivers/usb/cdns3/cdnsp-ring.c

1146

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/cdns3/cdnsp-ring.c

1156

td->preq->request.actual = remaining;

drivers/usb/cdns3/cdnsp-ring.c

1161

remaining = 0;

drivers/usb/cdns3/cdnsp-ring.c

1166

ep_trb_len = requested - remaining;

drivers/usb/cdns3/cdnsp-ring.c

1169

ep_trb_len - remaining;

drivers/usb/class/usbtmc.c

1000

this_part = remaining;

drivers/usb/class/usbtmc.c

1012

remaining -= this_part;

drivers/usb/class/usbtmc.c

1128

u32 remaining;

drivers/usb/class/usbtmc.c

1157

remaining = transfer_size;

drivers/usb/class/usbtmc.c

1158

if (remaining > INT_MAX)

drivers/usb/class/usbtmc.c

1159

remaining = INT_MAX;

drivers/usb/class/usbtmc.c

1164

while (remaining > 0) {

drivers/usb/class/usbtmc.c

1199

if (remaining > bufsize)

drivers/usb/class/usbtmc.c

1202

this_part = remaining;

drivers/usb/class/usbtmc.c

1238

remaining -= this_part;

drivers/usb/class/usbtmc.c

1386

u32 remaining;

drivers/usb/class/usbtmc.c

1421

remaining = count;

drivers/usb/class/usbtmc.c

1479

if (n_characters > remaining) {

drivers/usb/class/usbtmc.c

1490

remaining = n_characters;

drivers/usb/class/usbtmc.c

1496

if (actual > remaining)

drivers/usb/class/usbtmc.c

1497

actual = remaining;

drivers/usb/class/usbtmc.c

1499

remaining -= actual;

drivers/usb/class/usbtmc.c

1510

remaining,

drivers/usb/class/usbtmc.c

1537

u32 remaining, done;

drivers/usb/class/usbtmc.c

1598

remaining = transfersize;

drivers/usb/class/usbtmc.c

1632

remaining -= transfersize;

drivers/usb/class/usbtmc.c

1641

retval = usbtmc_generic_write(file_data, buf + transfersize, remaining,

drivers/usb/class/usbtmc.c

1644

if (done > remaining)

drivers/usb/class/usbtmc.c

1645

done = remaining;

drivers/usb/class/usbtmc.c

835

u32 remaining;

drivers/usb/class/usbtmc.c

855

remaining = transfer_size;

drivers/usb/class/usbtmc.c

865

remaining = max_transfer_size;

drivers/usb/class/usbtmc.c

997

if (remaining > urb->actual_length)

drivers/usb/core/hub.c

1669

int remaining = hdev->bus_mA -

drivers/usb/core/hub.c

1676

if (remaining < maxchild * unit_load)

drivers/usb/core/hub.c

5262

int remaining;

drivers/usb/core/hub.c

5268

remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;

drivers/usb/core/hub.c

5295

remaining -= delta;

drivers/usb/core/hub.c

5297

if (remaining < 0) {

drivers/usb/core/hub.c

5299

-remaining);

drivers/usb/core/hub.c

5300

remaining = 0;

drivers/usb/core/hub.c

5302

return remaining;

drivers/usb/dwc2/hcd.c

3793

unsigned int remaining;

drivers/usb/dwc2/hcd.c

3802

remaining = (hfnum & HFNUM_FRREM_MASK) >> HFNUM_FRREM_SHIFT;

drivers/usb/dwc2/hcd.c

3809

phy_clks = (interval - remaining) +

drivers/usb/dwc3/core.h

964

unsigned int remaining;

drivers/usb/dwc3/gadget.c

1484

unsigned int remaining = req->num_pending_sgs;

drivers/usb/dwc3/gadget.c

1485

unsigned int num_queued_sgs = req->request.num_mapped_sgs - remaining;

drivers/usb/dwc3/gadget.c

1496

for_each_sg(sg, s, remaining, i) {

drivers/usb/dwc3/gadget.c

1513

if ((i == remaining - 1) || !length)

drivers/usb/dwc3/gadget.c

199

req->remaining = 0;

drivers/usb/dwc3/gadget.c

3555

req->remaining += count;

drivers/usb/dwc3/gadget.c

3610

req->request.actual = req->request.length - req->remaining;

drivers/usb/dwc3/gadget.c

811

int remaining;

drivers/usb/dwc3/gadget.c

863

remaining = ram_depth - min_depth - dwc->last_fifo_depth;

drivers/usb/dwc3/gadget.c

864

remaining = max_t(int, 0, remaining);

drivers/usb/dwc3/gadget.c

871

if (remaining < fifo_size)

drivers/usb/dwc3/gadget.c

872

fifo_size = remaining;

drivers/usb/gadget/udc/atmel_usba_udc.c

113

remaining = __copy_to_user(buf, tmpbuf, len);

drivers/usb/gadget/udc/atmel_usba_udc.c

114

actual += len - remaining;

drivers/usb/gadget/udc/atmel_usba_udc.c

115

if (remaining)

drivers/usb/gadget/udc/atmel_usba_udc.c

89

size_t len, remaining, actual = 0;

drivers/usb/gadget/udc/bdc/bdc_ep.c

195

int remaining;

drivers/usb/gadget/udc/bdc/bdc_ep.c

202

remaining = req->usb_req.length % BD_MAX_BUFF_SIZE;

drivers/usb/gadget/udc/bdc/bdc_ep.c

203

if (remaining)

drivers/usb/gadget/udc/bdc/bdc_ep.c

207

remaining = req->usb_req.length / BD_MAX_BUFF_SIZE;

drivers/usb/gadget/udc/bdc/bdc_ep.c

208

bd_needed += remaining;

drivers/usb/gadget/udc/snps_udc_core.c

650

unsigned remaining = 0;

drivers/usb/gadget/udc/snps_udc_core.c

657

remaining = req->length - req->actual;

drivers/usb/gadget/udc/snps_udc_core.c

662

if (bytes > remaining)

drivers/usb/gadget/udc/snps_udc_core.c

663

bytes = remaining;

drivers/usb/host/max3421-hcd.c

823

size_t remaining, transfer_size;

drivers/usb/host/max3421-hcd.c

831

remaining = 0;

drivers/usb/host/max3421-hcd.c

833

remaining = urb->transfer_buffer_length - urb->actual_length;

drivers/usb/host/max3421-hcd.c

835

if (transfer_size > remaining)

drivers/usb/host/max3421-hcd.c

836

transfer_size = remaining;

drivers/usb/host/xhci-ring.c

2299

u32 remaining, requested;

drivers/usb/host/xhci-ring.c

2306

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/host/xhci-ring.c

2323

td->urb->actual_length = remaining;

drivers/usb/host/xhci-ring.c

2334

td->urb->actual_length = requested - remaining;

drivers/usb/host/xhci-ring.c

2355

td->urb->actual_length = requested - remaining;

drivers/usb/host/xhci-ring.c

2372

td->urb->actual_length = requested - remaining;

drivers/usb/host/xhci-ring.c

2397

u32 remaining, requested, ep_trb_len;

drivers/usb/host/xhci-ring.c

2405

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/host/xhci-ring.c

2416

if (remaining) {

drivers/usb/host/xhci-ring.c

2460

requested = remaining;

drivers/usb/host/xhci-ring.c

2466

remaining = 0;

drivers/usb/host/xhci-ring.c

2479

ep_trb_len - remaining;

drivers/usb/host/xhci-ring.c

2524

u32 remaining, requested, ep_trb_len;

drivers/usb/host/xhci-ring.c

2528

remaining = EVENT_TRB_LEN(le32_to_cpu(event->transfer_len));

drivers/usb/host/xhci-ring.c

2536

if (ep_trb != td->end_trb || remaining) {

drivers/usb/host/xhci-ring.c

2540

requested, remaining);

drivers/usb/host/xhci-ring.c

2548

td->urb->actual_length = remaining;

drivers/usb/host/xhci-ring.c

2570

td->urb->actual_length = requested - remaining;

drivers/usb/host/xhci-ring.c

2574

ep_trb_len - remaining;

drivers/usb/host/xhci-ring.c

2576

if (remaining > requested) {

drivers/usb/host/xhci-ring.c

2578

remaining);

drivers/usb/musb/tusb6010_omap.c

107

unsigned long remaining, flags, pio;

drivers/usb/musb/tusb6010_omap.c

115

remaining = musb_readl(ep_conf, TUSB_EP_TX_OFFSET);

drivers/usb/musb/tusb6010_omap.c

117

remaining = musb_readl(ep_conf, TUSB_EP_RX_OFFSET);

drivers/usb/musb/tusb6010_omap.c

119

remaining = TUSB_EP_CONFIG_XFR_SIZE(remaining);

drivers/usb/musb/tusb6010_omap.c

122

if (unlikely(remaining > chdat->transfer_len)) {

drivers/usb/musb/tusb6010_omap.c

124

chdat->tx ? "tx" : "rx", remaining);

drivers/usb/musb/tusb6010_omap.c

125

remaining = 0;

drivers/usb/musb/tusb6010_omap.c

128

channel->actual_len = chdat->transfer_len - remaining;

drivers/usb/musb/tusb6010_omap.c

131

dev_dbg(musb->controller, "DMA remaining %lu/%u\n", remaining, chdat->transfer_len);

drivers/vfio/pci/vfio_pci_igd.c

103

&pos, &remaining, bytes))

drivers/vfio/pci/vfio_pci_igd.c

108

if (remaining && pos < OPREGION_RVDA) {

drivers/vfio/pci/vfio_pci_igd.c

109

size_t bytes = min_t(size_t, remaining, OPREGION_RVDA - pos);

drivers/vfio/pci/vfio_pci_igd.c

113

&remaining, bytes))

drivers/vfio/pci/vfio_pci_igd.c

118

if (remaining && pos < OPREGION_RVDA + sizeof(__le64)) {

drivers/vfio/pci/vfio_pci_igd.c

119

size_t bytes = min_t(size_t, remaining,

drivers/vfio/pci/vfio_pci_igd.c

126

&pos, &remaining, bytes))

drivers/vfio/pci/vfio_pci_igd.c

131

if (remaining && pos < OPREGION_SIZE) {

drivers/vfio/pci/vfio_pci_igd.c

132

size_t bytes = min_t(size_t, remaining, OPREGION_SIZE - pos);

drivers/vfio/pci/vfio_pci_igd.c

136

&remaining, bytes))

drivers/vfio/pci/vfio_pci_igd.c

141

if (remaining &&

drivers/vfio/pci/vfio_pci_igd.c

143

remaining))

drivers/vfio/pci/vfio_pci_igd.c

51

size_t *remaining,

drivers/vfio/pci/vfio_pci_igd.c

59

*remaining -= bytes;

drivers/vfio/pci/vfio_pci_igd.c

71

size_t remaining;

drivers/vfio/pci/vfio_pci_igd.c

77

remaining = count;

drivers/vfio/pci/vfio_pci_igd.c

80

if (remaining && pos < OPREGION_VERSION) {

drivers/vfio/pci/vfio_pci_igd.c

81

size_t bytes = min_t(size_t, remaining, OPREGION_VERSION - pos);

drivers/vfio/pci/vfio_pci_igd.c

85

&remaining, bytes))

drivers/vfio/pci/vfio_pci_igd.c

90

if (remaining && pos < OPREGION_VERSION + sizeof(__le16)) {

drivers/vfio/pci/vfio_pci_igd.c

91

size_t bytes = min_t(size_t, remaining,

drivers/video/fbdev/sis/init.c

3387

unsigned short modeflag, tempax, tempbx = 0, remaining = 0;

drivers/video/fbdev/sis/init.c

3411

remaining = tempbx % 8;

drivers/video/fbdev/sis/init.c

3507

SiS_Pr->CCRT1CRTC[15] |= (remaining << 4);

drivers/w1/slaves/w1_ds28e17.c

194

int remaining = count;

drivers/w1/slaves/w1_ds28e17.c

232

remaining -= W1_F19_WRITE_DATA_LIMIT;

drivers/w1/slaves/w1_ds28e17.c

234

while (remaining > W1_F19_WRITE_DATA_LIMIT) {

drivers/w1/slaves/w1_ds28e17.c

248

remaining -= W1_F19_WRITE_DATA_LIMIT;

drivers/w1/slaves/w1_ds28e17.c

254

result = __w1_f19_i2c_write(sl, command, 1, p, remaining);

fs/afs/fsclient.c

312

call->remaining);

fs/afs/fsclient.c

316

call->remaining = 0;

fs/afs/fsclient.c

336

call->remaining = be64_to_cpu(call->tmp64);

fs/afs/fsclient.c

337

_debug("DATA length: %llu", call->remaining);

fs/afs/fsclient.c

339

if (call->remaining == 0)

fs/afs/fsclient.c

343

call->iov_len = umin(call->remaining, subreq->len - subreq->transferred);

fs/afs/fsclient.c

350

_debug("extract data %zu/%llu", count_before, call->remaining);

fs/afs/fsclient.c

354

call->remaining -= count_before - call->iov_len;

fs/afs/fsclient.c

359

if (call->remaining)

fs/afs/fsclient.c

363

afs_extract_discard(call, call->remaining);

fs/afs/fsclient.c

369

iov_iter_count(call->iter), call->remaining);

fs/afs/internal.h

167

unsigned long long remaining; /* How much is left to receive */

fs/afs/yfsclient.c

363

call->remaining);

fs/afs/yfsclient.c

367

call->remaining = 0;

fs/afs/yfsclient.c

382

call->remaining = be64_to_cpu(call->tmp64);

fs/afs/yfsclient.c

383

_debug("DATA length: %llu", call->remaining);

fs/afs/yfsclient.c

385

if (call->remaining == 0)

fs/afs/yfsclient.c

389

call->iov_len = min(call->remaining, subreq->len - subreq->transferred);

fs/afs/yfsclient.c

396

_debug("extract data %zu/%llu", count_before, call->remaining);

fs/afs/yfsclient.c

404

if (call->remaining)

fs/afs/yfsclient.c

408

afs_extract_discard(call, call->remaining);

fs/afs/yfsclient.c

414

iov_iter_count(call->iter), call->remaining);

fs/binfmt_elf.c

1596

unsigned count, size, names_ofs, remaining, n;

fs/binfmt_elf.c

1627

remaining = size - names_ofs;

fs/binfmt_elf.c

1637

filename = file_path(file, name_curpos, remaining);

fs/binfmt_elf.c

1649

n = (name_curpos + remaining) - filename;

fs/binfmt_elf.c

1650

remaining = filename - name_curpos;

fs/btrfs/bio.c

859

struct btrfs_bio *remaining = bbio->private;

fs/btrfs/bio.c

862

ASSERT(remaining);

fs/btrfs/bio.c

864

btrfs_bio_end_io(remaining, status);

fs/ceph/mds_client.c

2167

int *remaining = arg;

fs/ceph/mds_client.c

2172

if (*remaining <= 0)

fs/ceph/mds_client.c

2216

(*remaining)--;

fs/ceph/mds_client.c

2228

(*remaining)--;

fs/ceph/mds_client.c

2255

int remaining = trim_caps;

fs/ceph/mds_client.c

2257

ceph_iterate_session_caps(session, trim_caps_cb, &remaining);

fs/ceph/mds_client.c

2260

trim_caps - remaining);

fs/direct-io.c

337

unsigned long remaining;

fs/direct-io.c

345

remaining = --dio->refcount;

fs/direct-io.c

346

if (remaining == 1 && dio->waiter)

fs/direct-io.c

350

if (remaining == 0) {

fs/erofs/xattr.c

255

unsigned int xattr_header_sz, remaining, entry_sz;

fs/erofs/xattr.c

269

remaining = vi->xattr_isize - xattr_header_sz;

fs/erofs/xattr.c

272

while (remaining) {

fs/erofs/xattr.c

279

if (remaining < entry_sz) {

fs/erofs/xattr.c

283

remaining -= entry_sz;

fs/ext4/fast_commit.c

1769

int remaining, len;

fs/ext4/fast_commit.c

1797

remaining = len;

fs/ext4/fast_commit.c

1802

while (remaining > 0) {

fs/ext4/fast_commit.c

1804

map.m_len = remaining;

fs/ext4/fast_commit.c

1871

remaining -= map.m_len;

fs/ext4/fast_commit.c

1889

ext4_lblk_t cur, remaining;

fs/ext4/fast_commit.c

1894

remaining = le32_to_cpu(lrange.fc_len);

fs/ext4/fast_commit.c

1897

le32_to_cpu(lrange.fc_ino), cur, remaining);

fs/ext4/fast_commit.c

1912

while (remaining > 0) {

fs/ext4/fast_commit.c

1914

map.m_len = remaining;

fs/ext4/fast_commit.c

1920

remaining -= ret;

fs/ext4/fast_commit.c

1924

remaining -= map.m_len;

fs/ext4/fast_commit.c

703

int remaining;

fs/ext4/fast_commit.c

725

remaining = bsize - EXT4_FC_TAG_BASE_LEN - off;

fs/ext4/fast_commit.c

726

if (len <= remaining) {

fs/ext4/fast_commit.c

737

tl.fc_len = cpu_to_le16(remaining);

fs/ext4/fast_commit.c

739

memset(dst + EXT4_FC_TAG_BASE_LEN, 0, remaining);

fs/ext4/super.c

6913

uint64_t remaining = 0;

fs/ext4/super.c

6918

remaining = limit - curblock;

fs/ext4/super.c

6921

buf->f_bfree = min(buf->f_bfree, remaining);

fs/ext4/super.c

6922

buf->f_bavail = min(buf->f_bavail, remaining);

fs/ext4/super.c

6928

uint64_t remaining = 0;

fs/ext4/super.c

6931

remaining = limit - dquot->dq_dqb.dqb_curinodes;

fs/ext4/super.c

6934

buf->f_ffree = min(buf->f_ffree, remaining);

fs/f2fs/super.c

2181

uint64_t remaining = 0;

fs/f2fs/super.c

2186

remaining = limit - curblock;

fs/f2fs/super.c

2189

buf->f_bfree = min(buf->f_bfree, remaining);

fs/f2fs/super.c

2190

buf->f_bavail = min(buf->f_bavail, remaining);

fs/f2fs/super.c

2197

uint64_t remaining = 0;

fs/f2fs/super.c

2200

remaining = limit - dquot->dq_dqb.dqb_curinodes;

fs/f2fs/super.c

2203

buf->f_ffree = min(buf->f_ffree, remaining);

fs/fuse/virtio_fs.c

726

unsigned int remaining;

fs/fuse/virtio_fs.c

732

remaining = req->out.h.len - sizeof(req->out.h);

fs/fuse/virtio_fs.c

742

argsize > remaining) {

fs/fuse/virtio_fs.c

743

argsize = remaining;

fs/fuse/virtio_fs.c

750

remaining -= argsize;

fs/fuse/virtio_fs.c

755

args->out_args[args->out_numargs - 1].size = remaining;

fs/nfs/pnfs.c

2661

int remaining = 0;

fs/nfs/pnfs.c

2681

remaining++;

fs/nfs/pnfs.c

2686

if (remaining) {

fs/nfs/pnfs.c

727

int remaining = 0;

fs/nfs/pnfs.c

741

remaining++;

fs/nfs/pnfs.c

744

dprintk("%s:Return %i\n", __func__, remaining);

fs/nfs/pnfs.c

745

return remaining;

fs/nfsd/filecache.c

571

unsigned long remaining = list_lru_count_node(&nfsd_file_lru, nid);

fs/nfsd/filecache.c

573

while (remaining > 0) {

fs/nfsd/filecache.c

574

unsigned long nr = min(remaining, NFSD_FILE_GC_BATCH);

fs/nfsd/filecache.c

576

remaining -= nr;

fs/nfsd/filecache.c

581

remaining = 0;

fs/nfsd/nfscache.c

355

unsigned int remaining)

fs/nfsd/nfscache.c

363

if (remaining > RC_CSUMLEN)

fs/nfsd/nfscache.c

364

remaining = RC_CSUMLEN;

fs/nfsd/nfscache.c

365

if (xdr_buf_subsegment(buf, &subbuf, start, remaining))

fs/nfsd/nfscache.c

370

len = min_t(unsigned int, subbuf.head[0].iov_len, remaining);

fs/nfsd/nfscache.c

372

remaining -= len;

fs/nfsd/nfscache.c

378

while (remaining) {

fs/nfsd/nfscache.c

380

len = min_t(unsigned int, PAGE_SIZE - base, remaining);

fs/nfsd/nfscache.c

382

remaining -= len;

fs/nfsd/nfsctl.c

540

nfsd_print_version_support(struct nfsd_net *nn, char *buf, int remaining,

fs/nfsd/nfsctl.c

556

return snprintf(buf, remaining, format, sep,

fs/nfsd/nfsctl.c

564

int len, num, remaining;

fs/nfsd/nfsctl.c

637

remaining = SIMPLE_TRANSACTION_LIMIT;

fs/nfsd/nfsctl.c

645

len = nfsd_print_version_support(nn, buf, remaining,

fs/nfsd/nfsctl.c

647

if (len >= remaining)

fs/nfsd/nfsctl.c

649

remaining -= len;

fs/nfsd/nfsctl.c

658

len = snprintf(buf, remaining, "\n");

fs/nfsd/nfsctl.c

659

if (len >= remaining)

fs/nfsd/trace.h

1421

unsigned long remaining

fs/nfsd/trace.h

1423

TP_ARGS(removed, remaining),

fs/nfsd/trace.h

1426

__field(unsigned long, remaining)

fs/nfsd/trace.h

1430

__entry->remaining = remaining;

fs/nfsd/trace.h

1433

__entry->removed, __entry->remaining)

fs/nfsd/trace.h

1440

unsigned long remaining \

fs/nfsd/trace.h

1442

TP_ARGS(removed, remaining))

fs/pstore/platform.c

281

unsigned int remaining = READ_ONCE(kmsg_bytes);

fs/pstore/platform.c

304

while (total < remaining) {

fs/seq_file.c

863

int i, linelen, remaining = len;

fs/seq_file.c

872

linelen = min(remaining, rowsize);

fs/seq_file.c

873

remaining -= rowsize;

fs/smb/client/smb1transport.c

284

int remaining;

fs/smb/client/smb1transport.c

310

remaining = total_data_size - data_in_this_rsp;

fs/smb/client/smb1transport.c

313

remaining);

fs/smb/client/smb1transport.c

319

return remaining;

fs/smb/client/smb1transport.c

329

int remaining;

fs/smb/client/smb1transport.c

342

remaining = tgt_total_cnt - total_in_tgt;

fs/smb/client/smb1transport.c

344

if (remaining < 0) {

fs/smb/client/smb1transport.c

350

if (remaining == 0) {

fs/smb/client/smb1transport.c

357

if (remaining < total_in_src)

fs/smb/client/smb1transport.c

402

if (remaining != total_in_src) {

fs/smb/client/transport.c

1119

size_t remaining = rfclen - server->total_read;

fs/smb/client/transport.c

1121

while (remaining > 0) {

fs/smb/client/transport.c

1125

min_t(size_t, remaining,

fs/smb/client/transport.c

1130

remaining -= length;

fs/squashfs/cache.c

300

int remaining = length;

fs/squashfs/cache.c

313

if (bytes >= remaining) {

fs/squashfs/cache.c

314

memcpy(buffer, buff, remaining);

fs/squashfs/cache.c

315

remaining = 0;

fs/squashfs/cache.c

321

remaining -= bytes;

fs/squashfs/cache.c

325

return length - remaining;

fs/timerfd.c

177

ktime_t remaining;

fs/timerfd.c

180

remaining = alarm_expires_remaining(&ctx->t.alarm);

fs/timerfd.c

182

remaining = hrtimer_expires_remaining_adjusted(&ctx->t.tmr);

fs/timerfd.c

184

return remaining < 0 ? 0: remaining;

fs/xfs/scrub/stats.c

105

ret = scnprintf(buf, remaining,

fs/xfs/scrub/stats.c

124

remaining -= ret;

fs/xfs/scrub/stats.c

94

size_t remaining)

fs/xfs/scrub/trace.h

1401

__field(unsigned long, remaining)

fs/xfs/scrub/trace.h

1409

__entry->remaining = jiffies_to_msecs(iscan->__iget_deadline - jiffies);

fs/xfs/scrub/trace.h

1416

__entry->remaining,

fs/xfs/xfs_qm_bhv.c

36

uint64_t remaining = 0;

fs/xfs/xfs_qm_bhv.c

39

remaining = limit - blkres->reserved;

fs/xfs/xfs_qm_bhv.c

42

statp->f_bfree = min(statp->f_bfree, remaining);

fs/xfs/xfs_qm_bhv.c

49

uint64_t remaining = 0;

fs/xfs/xfs_qm_bhv.c

52

remaining = limit - dqp->q_ino.reserved;

fs/xfs/xfs_qm_bhv.c

55

statp->f_ffree = min(statp->f_ffree, remaining);

include/drm/drm_gem.h

620

unsigned long *remaining,

include/drm/gpu_scheduler.h

639

unsigned long remaining);

include/linux/closure.h

156

atomic_t remaining;

include/linux/closure.h

179

return atomic_read(&cl->remaining) & CLOSURE_REMAINING_MASK;

include/linux/closure.h

245

atomic_sub(CLOSURE_RUNNING, &cl->remaining);

include/linux/closure.h

281

BUG_ON((atomic_inc_return(&cl->remaining) &

include/linux/closure.h

284

atomic_inc(&cl->remaining);

include/linux/closure.h

293

unsigned old = atomic_read(&cl->remaining);

include/linux/closure.h

298

} while (!atomic_try_cmpxchg_acquire(&cl->remaining, &old, old + 1));

include/linux/closure.h

316

atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/linux/closure.h

326

atomic_set(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/linux/closure.h

335

atomic_set_release(&cl->remaining, CLOSURE_REMAINING_INITIALIZER);

include/net/mptcp.h

153

unsigned int *size, unsigned int remaining,

include/net/mptcp.h

272

unsigned int remaining,

include/net/netlink.h

1304

static inline int nla_ok(const struct nlattr *nla, int remaining)

include/net/netlink.h

1306

return remaining >= (int) sizeof(*nla) &&

include/net/netlink.h

1308

nla->nla_len <= remaining;

include/net/netlink.h

1319

static inline struct nlattr *nla_next(const struct nlattr *nla, int *remaining)

include/net/netlink.h

1323

*remaining -= totlen;

include/net/netlink.h

665

static inline int nlmsg_ok(const struct nlmsghdr *nlh, int remaining)

include/net/netlink.h

667

return (remaining >= (int) sizeof(struct nlmsghdr) &&

include/net/netlink.h

669

nlh->nlmsg_len <= remaining);

include/net/netlink.h

681

nlmsg_next(const struct nlmsghdr *nlh, int *remaining)

include/net/netlink.h

685

*remaining -= totlen;

include/net/rtnh.h

10

return remaining >= (int)sizeof(*rtnh) &&

include/net/rtnh.h

12

rtnh->rtnh_len <= remaining;

include/net/rtnh.h

16

int *remaining)

include/net/rtnh.h

20

*remaining -= totlen;

include/net/rtnh.h

8

static inline int rtnh_ok(const struct rtnexthop *rtnh, int remaining)

include/trace/events/rpcrdma.h

1914

unsigned int remaining,

include/trace/events/rpcrdma.h

1919

TP_ARGS(cid, remaining, seg_no, num_segs),

include/trace/events/rpcrdma.h

1924

__field(unsigned int, remaining)

include/trace/events/rpcrdma.h

1932

__entry->remaining = remaining;

include/trace/events/rpcrdma.h

1939

__entry->remaining, __entry->seg_no, __entry->num_segs

include/trace/events/sunrpc.h

969

__field(unsigned int, remaining)

include/trace/events/sunrpc.h

976

__entry->remaining = rqst->rq_slen - transport->xmit.offset;

include/trace/events/sunrpc.h

982

__entry->total, __entry->remaining

kernel/bpf/arena.c

545

long remaining, mapped = 0;

kernel/bpf/arena.c

590

remaining = page_cnt;

kernel/bpf/arena.c

593

while (remaining) {

kernel/bpf/arena.c

594

long this_batch = min(remaining, alloc_pages);

kernel/bpf/arena.c

624

remaining -= this_batch;

kernel/events/core.c

12241

ktime_t remaining = hrtimer_get_remaining(&hwc->hrtimer);

kernel/events/core.c

12242

local64_set(&hwc->period_left, ktime_to_ns(remaining));

kernel/module/internal.h

398

size_t remaining;

kernel/module/internal.h

405

for (modversion_ext_start(info, &ver); ver.remaining > 0; modversion_ext_advance(&ver))

kernel/module/version.c

119

start->remaining = 0;

kernel/module/version.c

125

start->remaining = sechdrs[crc_idx].sh_size / sizeof(*start->crc);

kernel/module/version.c

130

vers->remaining--;

kernel/sched/fair.c

6168

u64 runtime, remaining = 1;

kernel/sched/fair.c

6180

if (!remaining) {

kernel/sched/fair.c

6201

remaining = cfs_b->runtime;

kernel/sched/fair.c

6325

s64 remaining;

kernel/sched/fair.c

6332

remaining = ktime_to_ns(hrtimer_expires_remaining(refresh_timer));

kernel/sched/fair.c

6333

if (remaining < (s64)min_expire)

kernel/sched/psi.c

454

u32 remaining;

kernel/sched/psi.c

456

remaining = win->size - elapsed;

kernel/sched/psi.c

457

growth += div64_u64(win->prev_growth * remaining, win->size);

kernel/sched/wait.c

122

int remaining;

kernel/sched/wait.c

125

remaining = __wake_up_common(wq_head, mode, nr_exclusive, wake_flags,

kernel/sched/wait.c

129

return nr_exclusive - remaining;

kernel/time/posix-timers.c

679

ktime_t now, remaining, iv;

kernel/time/posix-timers.c

711

remaining = kc->timer_remaining(timr, now);

kernel/time/posix-timers.c

721

if (remaining <= 0) {

kernel/time/posix-timers.c

731

cur_setting->it_value = ktime_to_timespec64(remaining);

kernel/trace/ftrace.c

7670

unsigned long pg_remaining, remaining = 0;

kernel/trace/ftrace.c

7681

remaining += 1 << pg->order;

kernel/trace/ftrace.c

7685

pages -= remaining;

kernel/trace/ftrace.c

7692

remaining, skipped);

lib/bch.c

1142

unsigned int sum, x, y, remaining, ak = 0, xi[BCH_MAX_M];

lib/bch.c

1155

remaining = m;

lib/bch.c

1158

for (x = 0; (x <= GF_N(bch)) && remaining; x++) {

lib/bch.c

1165

remaining--;

lib/bch.c

1173

return remaining ? -1 : 0;

lib/closure.c

105

if (atomic_read(&cl->remaining) & CLOSURE_WAITING)

lib/closure.c

110

atomic_add(CLOSURE_WAITING + 1, &cl->remaining);

lib/closure.c

168

&cl->remaining);

lib/closure.c

206

unsigned old, new, v = atomic_read(&cl->remaining);

lib/closure.c

213

} while ((v = atomic_cmpxchg(&cl->remaining, old, new)) != old);

lib/closure.c

266

int r = atomic_read(&cl->remaining);

lib/closure.c

40

atomic_set(&cl->remaining,

lib/closure.c

61

closure_put_after_sub(cl, atomic_sub_return_release(v, &cl->remaining));

lib/closure.c

70

closure_put_after_sub(cl, atomic_dec_return_release(&cl->remaining));

lib/crc/s390/crc32.h

28

unsigned long prealign, aligned, remaining; \

lib/crc/s390/crc32.h

43

remaining = datalen & VX_ALIGN_MASK; \

lib/crc/s390/crc32.h

49

if (remaining) \

lib/crc/s390/crc32.h

50

crc = ___crc32_sw(crc, data + aligned, remaining); \

lib/crypto/tests/hash-test-template.h

430

int remaining = TEST_BUF_LEN;

lib/crypto/tests/hash-test-template.h

444

state->num_steps < ARRAY_SIZE(state->update_lens) - 1 && remaining;

lib/crypto/tests/hash-test-template.h

447

rand_length(min(remaining, 4096));

lib/crypto/tests/hash-test-template.h

448

remaining -= state->update_lens[state->num_steps];

lib/crypto/tests/hash-test-template.h

450

if (remaining)

lib/crypto/tests/hash-test-template.h

451

state->update_lens[state->num_steps++] = remaining;

lib/digsig.c

107

unsigned int remaining = endp - datap;

lib/digsig.c

108

pkey[i] = mpi_read_from_buffer(datap, &remaining);

lib/digsig.c

113

datap += remaining;

lib/dynamic_debug.c

832

pos += snprintf(buf + pos, remaining(pos), "<intr> ");

lib/dynamic_debug.c

834

pos += snprintf(buf + pos, remaining(pos), "[%d] ",

lib/dynamic_debug.c

839

pos += snprintf(buf + pos, remaining(pos), "%s:",

lib/dynamic_debug.c

842

pos += snprintf(buf + pos, remaining(pos), "%s:",

lib/dynamic_debug.c

845

pos += snprintf(buf + pos, remaining(pos), "%s:",

lib/dynamic_debug.c

848

pos += snprintf(buf + pos, remaining(pos), "%d:",

lib/dynamic_debug.c

851

pos += snprintf(buf + pos, remaining(pos), " ");

lib/hexdump.c

267

int i, linelen, remaining = len;

lib/hexdump.c

274

linelen = min(remaining, rowsize);

lib/hexdump.c

275

remaining -= rowsize;

lib/seq_buf.c

407

int i, linelen, remaining = len;

lib/seq_buf.c

415

linelen = min(remaining, rowsize);

lib/seq_buf.c

416

remaining -= rowsize;

lib/xz/xz_dec_test.c

104

size_t remaining;

lib/xz/xz_dec_test.c

118

remaining = size;

lib/xz/xz_dec_test.c

119

while ((remaining > 0 || buffers.out_pos == buffers.out_size)

lib/xz/xz_dec_test.c

123

buffers.in_size = min(remaining, sizeof(buffer_in));

lib/xz/xz_dec_test.c

128

remaining -= buffers.in_size;

lib/xz/xz_dec_test.c

144

return size - remaining - (buffers.in_size - buffers.in_pos);

lib/zstd/common/entropy_common.c

133

int const max = (2*threshold-1) - remaining;

lib/zstd/common/entropy_common.c

150

remaining -= count;

lib/zstd/common/entropy_common.c

153

remaining += count;

lib/zstd/common/entropy_common.c

159

if (remaining < threshold) {

lib/zstd/common/entropy_common.c

164

if (remaining <= 1) break;

lib/zstd/common/entropy_common.c

165

nbBits = ZSTD_highbit32(remaining) + 1;

lib/zstd/common/entropy_common.c

180

if (remaining != 1) return ERROR(corruption_detected);

lib/zstd/common/entropy_common.c

50

int remaining;

lib/zstd/common/entropy_common.c

78

remaining = (1<<nbBits)+1;

lib/zstd/compress/fse_compress.c

244

int remaining;

lib/zstd/compress/fse_compress.c

257

remaining = tableSize+1; /* +1 for extra accuracy */

lib/zstd/compress/fse_compress.c

261

while ((symbol < alphabetSize) && (remaining>1)) { /* stops at 1 */

lib/zstd/compress/fse_compress.c

293

int const max = (2*threshold-1) - remaining;

lib/zstd/compress/fse_compress.c

294

remaining -= count < 0 ? -count : count;

lib/zstd/compress/fse_compress.c

302

if (remaining<1) return ERROR(GENERIC);

lib/zstd/compress/fse_compress.c

303

while (remaining<threshold) { nbBits--; threshold>>=1; }

lib/zstd/compress/fse_compress.c

315

if (remaining != 1)

lib/zstd/compress/zstd_compress.c

4511

size_t remaining = srcSize;

lib/zstd/compress/zstd_compress.c

4524

while (remaining) {

lib/zstd/compress/zstd_compress.c

4527

ip, remaining,

lib/zstd/compress/zstd_compress.c

4532

U32 const lastBlock = lastFrameChunk & (blockSize == remaining);

lib/zstd/compress/zstd_compress.c

4533

assert(blockSize <= remaining);

lib/zstd/compress/zstd_compress.c

4594

assert(remaining >= blockSize);

lib/zstd/compress/zstd_compress.c

4595

remaining -= blockSize;

lib/zstd/compress/zstd_compress.c

6710

size_t blockSize, size_t remaining,

lib/zstd/compress/zstd_compress.c

6714

DEBUGLOG(6, "determine_blockSize : remainingSize = %zu", remaining);

lib/zstd/compress/zstd_compress.c

6717

return MIN(remaining, blockSize);

lib/zstd/compress/zstd_compress.c

6724

if (explicitBlockSize > remaining)

lib/zstd/compress/zstd_compress.c

6742

size_t remaining = srcSize;

lib/zstd/compress/zstd_compress.c

6751

if (remaining == 0) {

lib/zstd/compress/zstd_compress.c

6760

while (remaining) {

lib/zstd/compress/zstd_compress.c

6764

cctx->blockSizeMax, remaining,

lib/zstd/compress/zstd_compress.c

6766

U32 const lastBlock = (blockSize == remaining);

lib/zstd/compress/zstd_compress.c

6768

assert(blockSize <= remaining);

lib/zstd/compress/zstd_compress.c

6787

remaining -= blockSize;

lib/zstd/compress/zstd_compress.c

6843

remaining -= blockSize;

lib/zstd/compress/zstd_compress.c

7274

size_t remaining = srcSize;

lib/zstd/compress/zstd_compress.c

7308

remaining -= block.blockSize;

lib/zstd/compress/zstd_compress.c

7370

RETURN_ERROR_IF(remaining != 0, externalSequences_invalid, "Sequences must represent a total of exactly srcSize=%zu", srcSize);

lib/zstd/compress/zstd_ldm.c

551

size_t const remaining = (size_t)(iend - chunkStart);

lib/zstd/compress/zstd_ldm.c

553

(remaining < kMaxChunkSize) ? iend : chunkStart + kMaxChunkSize;

lib/zstd/compress/zstd_ldm.c

642

U32 const remaining, U32 const minMatch)

lib/zstd/compress/zstd_ldm.c

647

if (remaining >= sequence.litLength + sequence.matchLength) {

lib/zstd/compress/zstd_ldm.c

652

if (remaining <= sequence.litLength) {

lib/zstd/compress/zstd_ldm.c

654

} else if (remaining < sequence.litLength + sequence.matchLength) {

lib/zstd/compress/zstd_ldm.c

655

sequence.matchLength = remaining - sequence.litLength;

lib/zstd/compress/zstd_ldm.c

661

ZSTD_ldm_skipSequences(rawSeqStore, remaining, minMatch);

mm/hugetlb.c

3546

unsigned long remaining;

mm/hugetlb.c

3575

remaining = h->max_huge_pages - h->nr_huge_pages;

mm/hugetlb.c

3578

job.size = remaining;

mm/hugetlb.c

3579

job.min_chunk = remaining / hugepage_allocation_threads;

mm/hugetlb.c

3593

} while (remaining != (h->max_huge_pages - h->nr_huge_pages));

mm/percpu.c

1914

int remaining = atomic_dec_if_positive(&warn_limit);

mm/percpu.c

1916

if (remaining >= 0) {

mm/percpu.c

1921

if (remaining == 0)

mm/slub.c

2865

unsigned int batch, remaining;

mm/slub.c

2879

remaining = sheaf->size;

mm/slub.c

2887

return remaining;

mm/slub.c

2892

unsigned int remaining;

mm/slub.c

2897

remaining = __sheaf_flush_main_batch(s);

mm/slub.c

2899

} while (remaining);

mm/slub.c

2907

unsigned int remaining;

mm/slub.c

2915

remaining = __sheaf_flush_main_batch(s);

mm/slub.c

2917

} while (remaining);

mm/vmscan.c

3849

int remaining = MAX_LRU_BATCH;

mm/vmscan.c

3888

if (!--remaining)

mm/vmscan.c

4552

int remaining = scan_batch;

mm/vmscan.c

4590

if (!--remaining || max(isolated, skipped_zone) >= MIN_LRU_BATCH)

mm/vmscan.c

4600

if (!remaining || isolated >= MIN_LRU_BATCH)

mm/vmscan.c

4621

return isolated || !remaining ? scanned : 0;

mm/vmscan.c

5110

int remaining = MAX_LRU_BATCH;

mm/vmscan.c

5130

if (!--remaining)

mm/vmscan.c

5141

int remaining = MAX_LRU_BATCH;

mm/vmscan.c

5159

if (!--remaining)

mm/vmscan.c

7186

long remaining = 0;

mm/vmscan.c

7216

remaining = schedule_timeout(HZ/10);

mm/vmscan.c

7223

if (remaining) {

mm/vmscan.c

7240

if (!remaining &&

mm/vmscan.c

7259

if (remaining)

net/ceph/messenger_v2.c

3651

int remaining;

net/ceph/messenger_v2.c

3660

remaining = data_len(con->in_msg) + CEPH_EPILOGUE_PLAIN_LEN;

net/ceph/messenger_v2.c

3662

remaining);

net/ceph/messenger_v2.c

3664

set_in_skip(con, resid + remaining);

net/ceph/messenger_v2.c

3671

int remaining;

net/ceph/messenger_v2.c

3685

remaining = CEPH_EPILOGUE_PLAIN_LEN;

net/ceph/messenger_v2.c

3687

con->v2.in_cursor.total_resid, remaining);

net/ceph/messenger_v2.c

3689

set_in_skip(con, con->v2.in_cursor.total_resid + remaining);

net/ceph/messenger_v2.c

3712

int remaining;

net/ceph/messenger_v2.c

3720

remaining = CEPH_EPILOGUE_PLAIN_LEN + con->v2.data_len_remain;

net/ceph/messenger_v2.c

3722

set_in_skip(con, resid + remaining);

net/core/lwtunnel.c

182

int lwtunnel_valid_encap_type_attr(struct nlattr *attr, int remaining,

net/core/lwtunnel.c

191

while (rtnh_ok(rtnh, remaining)) {

net/core/lwtunnel.c

208

rtnh = rtnh_next(rtnh, &remaining);

net/core/pktgen.c

2327

s64 remaining;

net/core/pktgen.c

2333

remaining = ktime_to_ns(hrtimer_expires_remaining(&t.timer));

net/core/pktgen.c

2334

if (remaining <= 0)

net/core/pktgen.c

2338

if (remaining < 100000) {

net/core/skbuff.c

1480

u32 i, remaining = NAPI_SKB_CACHE_SIZE - NAPI_SKB_CACHE_FREE;

net/core/skbuff.c

1482

for (i = remaining; i < NAPI_SKB_CACHE_SIZE; i++)

net/core/skbuff.c

1488

nc->skb_cache + remaining);

net/core/skbuff.c

1489

nc->skb_count = remaining;

net/ipv4/fib_frontend.c

740

int err, remaining;

net/ipv4/fib_frontend.c

778

nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), remaining) {

net/ipv4/fib_semantics.c

1027

rtnh = rtnh_next(rtnh, &remaining);

net/ipv4/fib_semantics.c

1036

int remaining;

net/ipv4/fib_semantics.c

1041

nla_for_each_attr(nla, cfg->fc_mx, cfg->fc_mx_len, remaining) {

net/ipv4/fib_semantics.c

680

static int fib_count_nexthops(struct rtnexthop *rtnh, int remaining,

net/ipv4/fib_semantics.c

685

while (rtnh_ok(rtnh, remaining)) {

net/ipv4/fib_semantics.c

687

rtnh = rtnh_next(rtnh, &remaining);

net/ipv4/fib_semantics.c

691

if (remaining > 0) {

net/ipv4/fib_semantics.c

715

int remaining, struct fib_config *cfg,

net/ipv4/fib_semantics.c

728

if (!rtnh_ok(rtnh, remaining)) {

net/ipv4/fib_semantics.c

791

rtnh = rtnh_next(rtnh, &remaining);

net/ipv4/fib_semantics.c

866

int remaining, struct fib_config *cfg,

net/ipv4/fib_semantics.c

905

int remaining;

net/ipv4/fib_semantics.c

958

remaining = cfg->fc_mp_len;

net/ipv4/fib_semantics.c

963

if (!rtnh_ok(rtnh, remaining))

net/ipv4/inet_connection_sock.c

326

u32 remaining, offset;

net/ipv4/inet_connection_sock.c

345

remaining = high - low;

net/ipv4/inet_connection_sock.c

346

if (likely(remaining > 1))

net/ipv4/inet_connection_sock.c

347

remaining &= ~1U;

net/ipv4/inet_connection_sock.c

349

offset = get_random_u32_below(remaining);

net/ipv4/inet_connection_sock.c

357

for (i = 0; i < remaining; i += 2, port += 2) {

net/ipv4/inet_connection_sock.c

359

port -= remaining;

net/ipv4/inet_diag.c

185

int remaining;

net/ipv4/inet_diag.c

187

nlmsg_for_each_attr(nla, nlh, hdrlen, remaining) {

net/ipv4/inet_hashtables.c

1050

u32 remaining, offset;

net/ipv4/inet_hashtables.c

1070

remaining = high - low;

net/ipv4/inet_hashtables.c

1071

if (!local_ports && remaining > 1)

net/ipv4/inet_hashtables.c

1072

remaining &= ~1U;

net/ipv4/inet_hashtables.c

1079

offset %= remaining;

net/ipv4/inet_hashtables.c

1088

for (i = 0; i < remaining; i += step, port += step) {

net/ipv4/inet_hashtables.c

1090

port -= remaining;

net/ipv4/inet_hashtables.c

1148

if ((offset & 1) && remaining > 1)

net/ipv4/ipmr.c

2791

int remaining = nla_len(nla), vifi = 0;

net/ipv4/ipmr.c

2793

while (rtnh_ok(rtnh, remaining)) {

net/ipv4/ipmr.c

2797

rtnh = rtnh_next(rtnh, &remaining);

net/ipv4/ipmr.c

2800

return remaining > 0 ? -EINVAL : vifi;

net/ipv4/metrics.c

16

int remaining;

net/ipv4/metrics.c

18

nla_for_each_attr(nla, fc_mx, fc_mx_len, remaining) {

net/ipv4/tcp_ipv4.c

447

s32 remaining;

net/ipv4/tcp_ipv4.c

467

remaining = icsk->icsk_rto - usecs_to_jiffies(delta_us);

net/ipv4/tcp_ipv4.c

469

if (remaining > 0) {

net/ipv4/tcp_ipv4.c

470

tcp_reset_xmit_timer(sk, ICSK_TIME_RETRANS, remaining, false);

net/ipv4/tcp_output.c

1002

remaining -= TCPOLEN_WSCALE_ALIGNED;

net/ipv4/tcp_output.c

1007

remaining -= TCPOLEN_SACKPERM_ALIGNED;

net/ipv4/tcp_output.c

1016

if (remaining >= need) {

net/ipv4/tcp_output.c

1019

remaining -= need;

net/ipv4/tcp_output.c

1025

smc_set_option(tp, opts, &remaining);

net/ipv4/tcp_output.c

1031

if (remaining >= size) {

net/ipv4/tcp_output.c

1033

remaining -= size;

net/ipv4/tcp_output.c

1047

remaining >= TCPOLEN_ACCECN_BASE)) {

net/ipv4/tcp_output.c

1049

remaining -= tcp_options_fit_accecn(opts, 0, remaining);

net/ipv4/tcp_output.c

1052

bpf_skops_hdr_opt_len(sk, skb, NULL, NULL, 0, opts, &remaining);

net/ipv4/tcp_output.c

1054

return MAX_TCP_OPTION_SPACE - remaining;

net/ipv4/tcp_output.c

1068

unsigned int remaining = MAX_TCP_OPTION_SPACE;

net/ipv4/tcp_output.c

1073

remaining -= TCPOLEN_MD5SIG_ALIGNED;

net/ipv4/tcp_output.c

1084

remaining -= tcp_ao_len_aligned(key->ao_key);

net/ipv4/tcp_output.c

1090

remaining -= TCPOLEN_MSS_ALIGNED;

net/ipv4/tcp_output.c

1095

remaining -= TCPOLEN_WSCALE_ALIGNED;

net/ipv4/tcp_output.c

1108

remaining -= TCPOLEN_TSTAMP_ALIGNED;

net/ipv4/tcp_output.c

1113

remaining -= TCPOLEN_SACKPERM_ALIGNED;

net/ipv4/tcp_output.c

1121

if (remaining >= need) {

net/ipv4/tcp_output.c

1124

remaining -= need;

net/ipv4/tcp_output.c

1128

mptcp_set_option_cond(req, opts, &remaining);

net/ipv4/tcp_output.c

1130

smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);

net/ipv4/tcp_output.c

1134

synack_type != TCP_SYNACK_RETRANS && remaining >= TCPOLEN_ACCECN_BASE) {

net/ipv4/tcp_output.c

1136

remaining -= tcp_options_fit_accecn(opts, 0, remaining);

net/ipv4/tcp_output.c

1140

synack_type, opts, &remaining);

net/ipv4/tcp_output.c

1142

return MAX_TCP_OPTION_SPACE - remaining;

net/ipv4/tcp_output.c

1182

unsigned int remaining = MAX_TCP_OPTION_SPACE - size;

net/ipv4/tcp_output.c

1185

if (mptcp_established_options(sk, skb, &opt_size, remaining,

net/ipv4/tcp_output.c

1194

const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;

net/ipv4/tcp_output.c

1195

if (likely(remaining >= TCPOLEN_SACK_BASE_ALIGNED +

net/ipv4/tcp_output.c

1199

(remaining - TCPOLEN_SACK_BASE_ALIGNED) /

net/ipv4/tcp_output.c

1227

unsigned int remaining = MAX_TCP_OPTION_SPACE - size;

net/ipv4/tcp_output.c

1229

bpf_skops_hdr_opt_len(sk, skb, NULL, NULL, 0, opts, &remaining);

net/ipv4/tcp_output.c

1231

size = MAX_TCP_OPTION_SPACE - remaining;

net/ipv4/tcp_output.c

475

unsigned int *remaining)

net/ipv4/tcp_output.c

482

!*remaining)

net/ipv4/tcp_output.c

517

sock_ops.remaining_opt_len = *remaining;

net/ipv4/tcp_output.c

524

if (err || sock_ops.remaining_opt_len == *remaining)

net/ipv4/tcp_output.c

527

opts->bpf_opt_len = *remaining - sock_ops.remaining_opt_len;

net/ipv4/tcp_output.c

531

*remaining -= opts->bpf_opt_len;

net/ipv4/tcp_output.c

584

unsigned int *remaining)

net/ipv4/tcp_output.c

833

unsigned int *remaining)

net/ipv4/tcp_output.c

840

*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {

net/ipv4/tcp_output.c

842

*remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;

net/ipv4/tcp_output.c

851

unsigned int *remaining)

net/ipv4/tcp_output.c

858

*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {

net/ipv4/tcp_output.c

860

*remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;

net/ipv4/tcp_output.c

868

unsigned int *remaining)

net/ipv4/tcp_output.c

874

if (*remaining >= size) {

net/ipv4/tcp_output.c

876

*remaining -= size;

net/ipv4/tcp_output.c

904

int remaining)

net/ipv4/tcp_output.c

909

int rem = remaining;

net/ipv4/tcp_output.c

964

unsigned int remaining = MAX_TCP_OPTION_SPACE;

net/ipv4/tcp_output.c

972

remaining -= TCPOLEN_MD5SIG_ALIGNED;

net/ipv4/tcp_output.c

977

remaining -= tcp_ao_len_aligned(key->ao_key);

net/ipv4/tcp_output.c

991

remaining -= TCPOLEN_MSS_ALIGNED;

net/ipv4/tcp_output.c

997

remaining -= TCPOLEN_TSTAMP_ALIGNED;

net/ipv4/tcp_recovery.c

69

s32 remaining;

net/ipv4/tcp_recovery.c

84

remaining = tcp_rack_skb_timeout(tp, skb, reo_wnd);

net/ipv4/tcp_recovery.c

85

if (remaining <= 0) {

net/ipv4/tcp_recovery.c

90

*reo_timeout = max_t(u32, *reo_timeout, remaining);

net/ipv4/tcp_timer.c

33

s32 remaining;

net/ipv4/tcp_timer.c

43

remaining = user_timeout - elapsed;

net/ipv4/tcp_timer.c

44

if (remaining <= 0)

net/ipv4/tcp_timer.c

47

return min_t(u32, icsk->icsk_rto, msecs_to_jiffies(remaining));

net/ipv4/tcp_timer.c

53

u32 remaining, user_timeout;

net/ipv4/tcp_timer.c

63

remaining = msecs_to_jiffies(user_timeout) - elapsed;

net/ipv4/tcp_timer.c

64

remaining = max_t(u32, remaining, TCP_TIMEOUT_MIN);

net/ipv4/tcp_timer.c

66

return min_t(u32, remaining, when);

net/ipv4/udp.c

250

int low, high, remaining;

net/ipv4/udp.c

254

remaining = (high - low) + 1;

net/ipv4/udp.c

257

first = reciprocal_scale(rand, remaining) + low;

net/ipv6/route.c

5120

int remaining;

net/ipv6/route.c

5122

remaining = cfg->fc_mp_len;

net/ipv6/route.c

5125

if (!rtnh_ok(rtnh, remaining)) {

net/ipv6/route.c

5156

rtnh = rtnh_next(rtnh, &remaining);

net/ipv6/route.c

5157

} while (rtnh_ok(rtnh, remaining));

net/ipv6/route.c

5408

int remaining;

net/ipv6/route.c

5425

remaining = cfg->fc_mp_len;

net/ipv6/route.c

5431

while (rtnh_ok(rtnh, remaining)) {

net/ipv6/route.c

5474

rtnh = rtnh_next(rtnh, &remaining);

net/ipv6/route.c

5579

int remaining;

net/ipv6/route.c

5583

remaining = cfg->fc_mp_len;

net/ipv6/route.c

5587

while (rtnh_ok(rtnh, remaining)) {

net/ipv6/route.c

5607

rtnh = rtnh_next(rtnh, &remaining);

net/mac80211/offchannel.c

203

long remaining;

net/mac80211/offchannel.c

208

remaining = roc->start_time +

net/mac80211/offchannel.c

216

if (roc->abort || roc->hw_begun || remaining <= 0)

net/mac80211/offchannel.c

219

remaining_dur_min = min(remaining_dur_min, remaining);

net/mac80211/offchannel.c

527

unsigned long remaining;

net/mac80211/offchannel.c

538

remaining = cur_roc->start_time +

net/mac80211/offchannel.c

543

if (new_roc->duration > jiffies_to_msecs(remaining))

net/mpls/af_mpls.c

876

int remaining = len;

net/mpls/af_mpls.c

882

while (rtnh_ok(rtnh, remaining)) {

net/mpls/af_mpls.c

914

rtnh = rtnh_next(rtnh, &remaining);

net/mpls/af_mpls.c

918

return remaining > 0 ? 0 : nhs;

net/mpls/af_mpls.c

927

int remaining = cfg->rc_mp_len;

net/mpls/af_mpls.c

939

if (!rtnh_ok(rtnh, remaining))

net/mpls/af_mpls.c

965

rtnh = rtnh_next(rtnh, &remaining);

net/mptcp/options.c

656

unsigned int remaining,

net/mptcp/options.c

672

!mptcp_pm_add_addr_signal(msk, skb, opt_size, remaining, &addr,

net/mptcp/options.c

681

remaining += opt_size;

net/mptcp/options.c

686

if (remaining < len)

net/mptcp/options.c

720

unsigned int remaining,

net/mptcp/options.c

729

!(mptcp_pm_rm_addr_signal(msk, remaining, &rm_list)))

net/mptcp/options.c

735

if (remaining < len)

net/mptcp/options.c

750

unsigned int remaining,

net/mptcp/options.c

762

if (remaining < TCPOLEN_MPTCP_PRIO_ALIGN)

net/mptcp/options.c

776

unsigned int remaining,

net/mptcp/options.c

781

if (remaining < TCPOLEN_MPTCP_RST)

net/mptcp/options.c

795

unsigned int remaining,

net/mptcp/options.c

804

if (remaining < TCPOLEN_MPTCP_FASTCLOSE)

net/mptcp/options.c

818

unsigned int remaining,

net/mptcp/options.c

826

if (remaining < TCPOLEN_MPTCP_FAIL)

net/mptcp/options.c

840

unsigned int *size, unsigned int remaining,

net/mptcp/options.c

858

if (mptcp_established_options_fastclose(sk, &opt_size, remaining, opts) ||

net/mptcp/options.c

859

mptcp_established_options_mp_fail(sk, &opt_size, remaining, opts)) {

net/mptcp/options.c

861

remaining -= opt_size;

net/mptcp/options.c

864

if (mptcp_established_options_rst(sk, skb, &opt_size, remaining, opts)) {

net/mptcp/options.c

866

remaining -= opt_size;

net/mptcp/options.c

879

remaining - opt_size, opts)) {

net/mptcp/options.c

881

remaining -= opt_size - mp_fail_size;

net/mptcp/options.c

889

if (WARN_ON_ONCE(opt_size > remaining))

net/mptcp/options.c

893

remaining -= opt_size;

net/mptcp/options.c

894

if (mptcp_established_options_add_addr(sk, skb, &opt_size, remaining, opts)) {

net/mptcp/options.c

896

remaining -= opt_size;

net/mptcp/options.c

898

} else if (mptcp_established_options_rm_addr(sk, &opt_size, remaining, opts)) {

net/mptcp/options.c

900

remaining -= opt_size;

net/mptcp/options.c

904

if (mptcp_established_options_mp_prio(sk, &opt_size, remaining, opts)) {

net/mptcp/options.c

906

remaining -= opt_size;

net/mptcp/pm.c

859

unsigned int opt_size, unsigned int remaining,

net/mptcp/pm.c

879

remaining += opt_size;

net/mptcp/pm.c

887

if (remaining < mptcp_add_addr_len(family, *echo, port))

net/mptcp/pm.c

905

bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,

net/mptcp/pm.c

923

if (remaining < len)

net/mptcp/protocol.h

1196

unsigned int opt_size, unsigned int remaining,

net/mptcp/protocol.h

1199

bool mptcp_pm_rm_addr_signal(struct mptcp_sock *msk, unsigned int remaining,

net/rxrpc/ar-internal.h

278

struct rxrpc_txbuf *(*alloc_txbuf)(struct rxrpc_call *call, size_t remaining, gfp_t gfp);

net/rxrpc/input_rack.c

220

ktime_t remaining;

net/rxrpc/input_rack.c

227

remaining = ktime_sub(ktime_add(xmit_ts, lost_after), now);

net/rxrpc/input_rack.c

228

if (remaining <= 0) {

net/rxrpc/input_rack.c

232

timeout = max(remaining, timeout);

net/sctp/chunk.c

150

size_t len, first_len, max_data, remaining;

net/sctp/chunk.c

237

for (remaining = msg_len; remaining; remaining -= len) {

net/sctp/chunk.c

240

if (remaining == msg_len) {

net/sctp/chunk.c

249

if (len >= remaining) {

net/sctp/chunk.c

251

len = remaining;

net/sctp/socket.c

8399

int low, high, remaining, index;

net/sctp/socket.c

8403

remaining = (high - low) + 1;

net/sctp/socket.c

8404

rover = get_random_u32_below(remaining) + low;

net/sctp/socket.c

8423

} while (--remaining > 0);

net/sctp/socket.c

8427

if (remaining <= 0)

net/sunrpc/svc.c

1778

size_t len, remaining;

net/sunrpc/svc.c

1786

remaining = total;

net/sunrpc/svc.c

1792

remaining -= len;

net/sunrpc/svc.c

1795

if (remaining) {

net/sunrpc/svc.c

1796

len = min_t(size_t, remaining, PAGE_SIZE);

net/sunrpc/svc_xprt.c

1388

char *pos, int remaining)

net/sunrpc/svc_xprt.c

1392

len = snprintf(pos, remaining, "%s %u\n",

net/sunrpc/svc_xprt.c

1395

if (len >= remaining)

net/sunrpc/svcsock.c

207

static int svc_one_sock_name(struct svc_sock *svsk, char *buf, int remaining)

net/sunrpc/svcsock.c

216

len = snprintf(buf, remaining, "ipv4 %s %pI4 %d\n",

net/sunrpc/svcsock.c

223

len = snprintf(buf, remaining, "ipv6 %s %pI6 %d\n",

net/sunrpc/svcsock.c

230

len = snprintf(buf, remaining, "*unknown-%d*\n",

net/sunrpc/svcsock.c

234

if (len >= remaining) {

net/sunrpc/xdr.c

1599

size_t remaining = xdr_stream_remaining(xdr);

net/sunrpc/xdr.c

160

unsigned int offset, len, remaining;

net/sunrpc/xdr.c

1607

buf->page_len, remaining);

net/sunrpc/xdr.c

1611

xdr_set_tail_base(xdr, base, remaining);

net/sunrpc/xdr.c

164

remaining = xdr->page_len;

net/sunrpc/xdr.c

165

while (remaining > 0) {

net/sunrpc/xdr.c

166

len = min_t(unsigned int, remaining,

net/sunrpc/xdr.c

169

remaining -= len;

net/sunrpc/xdr.c

1729

unsigned int remaining, len;

net/sunrpc/xdr.c

1736

for (remaining = nbytes; remaining;) {

net/sunrpc/xdr.c

1741

if (remaining <= len) {

net/sunrpc/xdr.c

1743

(remaining + xdr_pad_size(nbytes)));

net/sunrpc/xdr.c

1749

remaining -= len;

net/sunrpc/xprtrdma/rpc_rdma.c

131

unsigned int count, remaining, offset;

net/sunrpc/xprtrdma/rpc_rdma.c

137

remaining = xdr->page_len;

net/sunrpc/xprtrdma/rpc_rdma.c

140

while (remaining) {

net/sunrpc/xprtrdma/rpc_rdma.c

141

remaining -= min_t(unsigned int,

net/sunrpc/xprtrdma/rpc_rdma.c

142

PAGE_SIZE - offset, remaining);

net/sunrpc/xprtrdma/rpc_rdma.c

601

unsigned int page_base, len, remaining;

net/sunrpc/xprtrdma/rpc_rdma.c

607

remaining = xdr->page_len;

net/sunrpc/xprtrdma/rpc_rdma.c

608

while (remaining) {

net/sunrpc/xprtrdma/rpc_rdma.c

610

len = min_t(unsigned int, PAGE_SIZE - page_base, remaining);

net/sunrpc/xprtrdma/rpc_rdma.c

621

remaining -= len;

net/sunrpc/xprtrdma/rpc_rdma.c

680

unsigned int len, page_base, remaining;

net/sunrpc/xprtrdma/rpc_rdma.c

688

remaining = xdr->page_len;

net/sunrpc/xprtrdma/rpc_rdma.c

689

while (remaining) {

net/sunrpc/xprtrdma/rpc_rdma.c

692

len = min_t(unsigned int, PAGE_SIZE - page_base, remaining);

net/sunrpc/xprtrdma/rpc_rdma.c

698

remaining -= len;

net/sunrpc/xprtrdma/svc_rdma_rw.c

453

unsigned int remaining,

net/sunrpc/xprtrdma/svc_rdma_rw.c

464

info->wi_next_off += remaining;

net/sunrpc/xprtrdma/svc_rdma_rw.c

467

bvec_len = min_t(unsigned int, remaining,

net/sunrpc/xprtrdma/svc_rdma_rw.c

471

remaining -= bvec_len;

net/sunrpc/xprtrdma/svc_rdma_rw.c

475

} while (remaining);

net/sunrpc/xprtrdma/svc_rdma_rw.c

488

unsigned int remaining)

net/sunrpc/xprtrdma/svc_rdma_rw.c

504

write_len = min(remaining, seg->rs_length - info->wi_seg_off);

net/sunrpc/xprtrdma/svc_rdma_rw.c

528

remaining -= write_len;

net/sunrpc/xprtrdma/svc_rdma_rw.c

529

} while (remaining);

net/sunrpc/xprtrdma/svc_rdma_rw.c

534

trace_svcrdma_small_wrch_err(&cc->cc_cid, remaining, info->wi_seg_no,

net/sunrpc/xprtrdma/svc_rdma_rw.c

852

unsigned int remaining)

net/sunrpc/xprtrdma/svc_rdma_rw.c

857

numpages = PAGE_ALIGN(head->rc_pageoff + remaining) >> PAGE_SHIFT;

net/sunrpc/xprtrdma/svc_rdma_rw.c

864

page_len = min_t(unsigned int, remaining,

net/sunrpc/xprtrdma/svc_rdma_rw.c

879

remaining -= page_len;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

432

u32 *remaining, unsigned int segno)

net/sunrpc/xprtrdma/svc_rdma_sendto.c

443

length = min_t(u32, *remaining, segment->rs_length);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

444

*remaining -= length;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

469

u32 remaining = chunk->ch_payload_length;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

485

ret = svc_rdma_encode_write_segment(sctxt, chunk, &remaining, segno);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

633

unsigned int len, remaining;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

644

remaining = xdr->page_len;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

645

while (remaining) {

net/sunrpc/xprtrdma/svc_rdma_sendto.c

646

len = min_t(u32, PAGE_SIZE - pageoff, remaining);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

652

remaining -= len;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

681

unsigned int remaining;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

688

remaining = xdr->page_len;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

689

while (remaining) {

net/sunrpc/xprtrdma/svc_rdma_sendto.c

691

remaining -= min_t(u32, PAGE_SIZE - offset, remaining);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

747

unsigned int len, remaining;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

758

remaining = xdr->page_len;

net/sunrpc/xprtrdma/svc_rdma_sendto.c

759

while (remaining) {

net/sunrpc/xprtrdma/svc_rdma_sendto.c

760

len = min_t(u32, PAGE_SIZE - pageoff, remaining);

net/sunrpc/xprtrdma/svc_rdma_sendto.c

762

remaining -= len;

net/tipc/socket.c

3013

u32 remaining = (TIPC_MAX_PORT - TIPC_MIN_PORT) + 1;

net/tipc/socket.c

3014

u32 portid = get_random_u32_below(remaining) + TIPC_MIN_PORT;

net/tipc/socket.c

3016

while (remaining--) {

net/tls/tls_device_fallback.c

228

int remaining;

net/tls/tls_device_fallback.c

258

remaining = *sync_size;

net/tls/tls_device_fallback.c

259

for (i = 0; remaining > 0; i++) {

net/tls/tls_device_fallback.c

266

remaining -= skb_frag_size(frag);

net/tls/tls_device_fallback.c

268

if (remaining < 0)

net/tls/tls_device_fallback.c

269

sg_in[i].length += remaining;

net/wireless/util.c

770

int remaining = skb->len - offset;

net/wireless/util.c

777

if (sizeof(hdr) > remaining)

net/wireless/util.c

788

if (subframe_len > remaining)

net/wireless/util.c

864

int remaining = skb->len - offset;

net/wireless/util.c

869

if (copy_len > remaining)

net/wireless/util.c

881

if (subframe_len > remaining)

net/wireless/util.c

890

last = remaining <= subframe_len + padding;

net/xfrm/trace_iptfs.h

151

TP_PROTO(struct sk_buff *skb, u32 remaining),

net/xfrm/trace_iptfs.h

152

TP_ARGS(skb, remaining),

net/xfrm/trace_iptfs.h

155

__field(u32, remaining)),

net/xfrm/trace_iptfs.h

158

__entry->remaining = remaining;

net/xfrm/trace_iptfs.h

161

__entry->skb, __entry->skb_len, __entry->remaining));

net/xfrm/xfrm_compat.c

307

int len, remaining;

net/xfrm/xfrm_compat.c

316

nla_for_each_attr(nla, attrs, len, remaining) {

net/xfrm/xfrm_iptfs.c

1009

if (remaining < 6) {

net/xfrm/xfrm_iptfs.c

1012

remaining);

net/xfrm/xfrm_iptfs.c

1013

data += remaining;

net/xfrm/xfrm_iptfs.c

1089

remaining = skb->len;

net/xfrm/xfrm_iptfs.c

1101

remaining >= iphlen) {

net/xfrm/xfrm_iptfs.c

1119

capturelen = min(iplen, remaining);

net/xfrm/xfrm_iptfs.c

1223

u32 blkoff, data, remaining;

net/xfrm/xfrm_iptfs.c

1250

remaining = sizeof(iptcch) - sizeof(*ipth);

net/xfrm/xfrm_iptfs.c

1251

if (skb_copy_seq_read(&skbseq, data, ipth + 1, remaining)) {

net/xfrm/xfrm_iptfs.c

1255

data += remaining;

net/xfrm/xfrm_iptfs.c

2199

int remaining;

net/xfrm/xfrm_iptfs.c

2234

remaining = mtu - (skb->len - sizeof(struct ip_iptfs_hdr));

net/xfrm/xfrm_iptfs.c

2259

trace_iptfs_ingress_nth_peek(skb2, remaining);

net/xfrm/xfrm_iptfs.c

2260

if (skb2->len > remaining)

net/xfrm/xfrm_iptfs.c

2295

remaining -= skb2->len;

net/xfrm/xfrm_iptfs.c

748

u32 remaining = skb->len - data;

net/xfrm/xfrm_iptfs.c

754

return data + min(blkoff, remaining);

net/xfrm/xfrm_iptfs.c

773

return data + remaining;

net/xfrm/xfrm_iptfs.c

792

return data + remaining;

net/xfrm/xfrm_iptfs.c

804

if (remaining < rrem || blkoff < rrem) {

net/xfrm/xfrm_iptfs.c

868

fraglen = min(blkoff, remaining);

net/xfrm/xfrm_iptfs.c

884

remaining -= copylen;

net/xfrm/xfrm_iptfs.c

888

fraglen = min(blkoff, remaining);

net/xfrm/xfrm_iptfs.c

939

return data + min(blkoff, remaining);

net/xfrm/xfrm_iptfs.c

954

u32 first_iplen, iphlen, iplen, remaining, tail;

net/xfrm/xfrm_iptfs.c

978

remaining = tail - data;

net/xfrm/xfrm_iptfs.c

981

iphlen = min_t(u32, remaining, 6);

net/xfrm/xfrm_iptfs.c

990

if (remaining < 4) {

net/xfrm/xfrm_iptfs.c

993

remaining);

net/xfrm/xfrm_iptfs.c

994

data += remaining;

sound/soc/intel/avs/cldma.c

113

if (!cl->remaining)

sound/soc/intel/avs/cldma.c

126

if (!cl->remaining)

sound/soc/intel/avs/cldma.c

202

cl->remaining = size;

sound/soc/intel/avs/cldma.c

209

int remaining = cl->buffer_size;

sound/soc/intel/avs/cldma.c

214

while (remaining > 0) {

sound/soc/intel/avs/cldma.c

224

remaining -= chunk;

sound/soc/intel/avs/cldma.c

226

bdl[3] = (remaining > 0) ? 0 : cpu_to_le32(0x01);

sound/soc/intel/avs/cldma.c

48

unsigned int remaining;

sound/soc/intel/avs/cldma.c

64

if (cl->remaining > cl->buffer_size)

sound/soc/intel/avs/cldma.c

67

size = cl->remaining;

sound/soc/intel/avs/cldma.c

78

cl->remaining -= ss;

sound/soc/intel/avs/cldma.c

83

cl->remaining -= size;

sound/soc/intel/avs/messages.c

273

size_t remaining, tx_size;

sound/soc/intel/avs/messages.c

277

remaining = request_size;

sound/soc/intel/avs/messages.c

278

tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);

sound/soc/intel/avs/messages.c

279

final = (tx_size == remaining);

sound/soc/intel/avs/messages.c

288

remaining -= tx_size;

sound/soc/intel/avs/messages.c

291

while (remaining) {

sound/soc/intel/avs/messages.c

294

offset = request_size - remaining;

sound/soc/intel/avs/messages.c

295

tx_size = min_t(size_t, AVS_MAILBOX_SIZE, remaining);

sound/soc/intel/avs/messages.c

296

final = (tx_size == remaining);

sound/soc/intel/avs/messages.c

305

remaining -= tx_size;

sound/soc/intel/avs/topology.c

1966

size_t remaining = le32_to_cpu(manifest->priv.size);

sound/soc/intel/avs/topology.c

1971

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

1987

remaining -= offset;

sound/soc/intel/avs/topology.c

1990

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2002

remaining -= offset;

sound/soc/intel/avs/topology.c

2005

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2017

remaining -= offset;

sound/soc/intel/avs/topology.c

2020

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2032

remaining -= offset;

sound/soc/intel/avs/topology.c

2035

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2047

remaining -= offset;

sound/soc/intel/avs/topology.c

2050

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2062

remaining -= offset;

sound/soc/intel/avs/topology.c

2065

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2077

remaining -= offset;

sound/soc/intel/avs/topology.c

2080

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2092

has_init_config ? offset : remaining);

sound/soc/intel/avs/topology.c

2099

remaining -= offset;

sound/soc/intel/avs/topology.c

2103

ret = avs_tplg_parse_initial_configs(comp, tuples, remaining, &offset);

sound/soc/intel/avs/topology.c

2107

remaining -= offset;

sound/soc/intel/avs/topology.c

2110

ret = avs_tplg_vendor_array_lookup(tuples, remaining,

sound/soc/intel/avs/topology.c

2122

return avs_tplg_parse_nhlt_configs(comp, tuples, remaining);

sound/soc/intel/avs/trace.c

21

size_t remaining = size;

sound/soc/intel/avs/trace.c

24

while (remaining > 0) {

sound/soc/intel/avs/trace.c

27

chunk = min_t(size_t, remaining, MAX_CHUNK_SIZE);

sound/soc/intel/avs/trace.c

30

remaining -= chunk;

sound/soc/sof/ipc3-loader.c

145

ssize_t remaining;

sound/soc/sof/ipc3-loader.c

150

remaining = head->full_size - head->header_size;

sound/soc/sof/ipc3-loader.c

151

if (remaining < 0 || remaining > sdev->basefw.fw->size)

sound/soc/sof/ipc3-loader.c

171

while (remaining > sizeof(*elem_hdr)) {

sound/soc/sof/ipc3-loader.c

178

elem_hdr->size > remaining) {

sound/soc/sof/ipc3-loader.c

222

remaining -= elem_hdr->size;

sound/soc/sof/ipc3-loader.c

226

if (remaining) {

sound/soc/sof/ipc3-loader.c

241

size_t remaining;

sound/soc/sof/ipc3-loader.c

249

remaining = module->size;

sound/soc/sof/ipc3-loader.c

252

if (remaining < sizeof(*block)) {

sound/soc/sof/ipc3-loader.c

258

remaining -= sizeof(*block);

sound/soc/sof/ipc3-loader.c

300

if (remaining < block->size) {

sound/soc/sof/ipc3-loader.c

306

remaining -= block->size;

sound/soc/sof/ipc3-loader.c

322

size_t remaining;

sound/soc/sof/ipc3-loader.c

339

remaining = fw->size - sizeof(*header) - payload_offset;

sound/soc/sof/ipc3-loader.c

341

if (remaining > fw->size) {

sound/soc/sof/ipc3-loader.c

348

if (remaining < sizeof(*module)) {

sound/soc/sof/ipc3-loader.c

355

remaining -= sizeof(*module);

sound/soc/sof/ipc3-loader.c

364

if (remaining < module->size) {

sound/soc/sof/ipc3-loader.c

370

remaining -= module->size;

sound/soc/sof/ipc4-loader.c

101

remaining -= fw_header->len;

sound/soc/sof/ipc4-loader.c

103

if (remaining < fw_header->num_module_entries * sizeof(*fm_entry)) {

sound/soc/sof/ipc4-loader.c

111

remaining -= (fw_header->num_module_entries * sizeof(*fm_entry));

sound/soc/sof/ipc4-loader.c

116

if (remaining < (fm_entry->cfg_offset + fm_entry->cfg_count) *

sound/soc/sof/ipc4-loader.c

30

ssize_t remaining;

sound/soc/sof/ipc4-loader.c

39

remaining = fw->size;

sound/soc/sof/ipc4-loader.c

40

if (remaining <= sizeof(*ext_man_hdr)) {

sound/soc/sof/ipc4-loader.c

41

dev_err(sdev->dev, "Firmware size is too small: %zu\n", remaining);

sound/soc/sof/ipc4-loader.c

62

if (remaining <= ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header)) {

sound/soc/sof/ipc4-loader.c

64

remaining, ext_man_hdr->len + fw_hdr_offset + sizeof(*fw_header));

sound/soc/sof/ipc4-loader.c

70

remaining -= (ext_man_hdr->len + fw_hdr_offset);

sound/soc/sof/ipc4-loader.c

72

if (remaining <= fw_header->len) {

sound/soc/sof/ipc4-mtrace.c

299

int i, ret, offset, remaining;

sound/soc/sof/ipc4-mtrace.c

314

remaining = 241 - offset;

sound/soc/sof/ipc4-mtrace.c

315

snprintf(buf + offset, remaining, "%2d: 0x%08x\n", i,

sound/soc/sof/ipc4.c

463

size_t remaining = payload_bytes;

sound/soc/sof/ipc4.c

512

if (remaining > payload_limit) {

sound/soc/sof/ipc4.c

515

chunk_size = remaining;

sound/soc/sof/ipc4.c

573

remaining = rx_size;

sound/soc/sof/ipc4.c

575

remaining = rx_size;

sound/soc/sof/ipc4.c

580

remaining -= chunk_size;

sound/soc/sof/ipc4.c

581

} while (remaining);

sound/soc/sof/sof-client-ipc-msg-injector.c

106

remaining -= header_size;

sound/soc/sof/sof-client-ipc-msg-injector.c

108

if (!remaining)

sound/soc/sof/sof-client-ipc-msg-injector.c

111

if (remaining > ipc4_msg->data_size)

sound/soc/sof/sof-client-ipc-msg-injector.c

112

remaining = ipc4_msg->data_size;

sound/soc/sof/sof-client-ipc-msg-injector.c

115

if (copy_to_user(buffer + *ppos, ipc4_msg->data_ptr, remaining))

sound/soc/sof/sof-client-ipc-msg-injector.c

118

*ppos += remaining;

sound/soc/sof/sof-client-ipc-msg-injector.c

80

size_t remaining;

sound/soc/sof/sof-client-ipc-msg-injector.c

89

remaining = header_size;

sound/soc/sof/sof-client-ipc-msg-injector.c

94

remaining += ipc4_msg->data_size;

sound/soc/sof/sof-client-ipc-msg-injector.c

96

if (count > remaining)

sound/soc/sof/sof-client-ipc-msg-injector.c

97

count = remaining;

sound/soc/sof/sof-client-ipc-msg-injector.c

98

else if (count < remaining)

sound/soc/sof/sof-client-ipc-msg-injector.c

99

remaining = count;

sound/soc/sof/sof-client-probes.c

211

int remaining, offset;

sound/soc/sof/sof-client-probes.c

241

remaining = PAGE_SIZE - offset;

sound/soc/sof/sof-client-probes.c

243

ret = ipc->point_print(cdev, buf + offset, remaining, &desc[i]);

sound/soc/sof/sof-client-probes.c

245

ret = snprintf(buf + offset, remaining,

sound/soc/sof/sof-client-probes.c

249

if (ret < 0 || ret >= remaining) {

sound/usb/midi.c

492

int remaining = buffer_length;

sound/usb/midi.c

530

while (remaining >= 4) {

sound/usb/midi.c

542

int tmp_length = remaining - 2;

sound/usb/midi.c

561

remaining -= source_length;

tools/arch/s390/include/uapi/asm/kvm.h

47

__u64 remaining;

tools/hv/hv_kvp_daemon.c

738

static void kvp_extract_routes(const char *line, void **output, size_t *remaining)

tools/hv/hv_kvp_daemon.c

755

if (*remaining >= (next_char - address) + 1) {

tools/hv/hv_kvp_daemon.c

762

*remaining -= next_char - address;

tools/hv/hv_kvp_daemon.c

767

*remaining -= 1;

tools/hv/hv_kvp_daemon.c

780

size_t alloc_size = 0, remaining = buffer_len - 1;

tools/hv/hv_kvp_daemon.c

801

kvp_extract_routes(line + strlen(needle), &output, &remaining);

tools/lib/bpf/nlattr.c

25

static struct nlattr *nla_next(const struct nlattr *nla, int *remaining)

tools/lib/bpf/nlattr.c

29

*remaining -= totlen;

tools/lib/bpf/nlattr.c

33

static int nla_ok(const struct nlattr *nla, int remaining)

tools/lib/bpf/nlattr.c

35

return remaining >= (int)sizeof(*nla) &&

tools/lib/bpf/nlattr.c

37

nla->nla_len <= remaining;

tools/perf/ui/browsers/hists.c

2007

u16 remaining = h->nr_rows - h->row_offset;

tools/perf/ui/browsers/hists.c

2008

if (offset > remaining) {

tools/perf/ui/browsers/hists.c

2009

offset -= remaining;

tools/perf/ui/stdio/hist.c

121

u64 remaining;

tools/perf/ui/stdio/hist.c

127

remaining = total_samples;

tools/perf/ui/stdio/hist.c

136

remaining -= cumul;

tools/perf/ui/stdio/hist.c

147

if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))

tools/perf/ui/stdio/hist.c

179

remaining && remaining != total_samples) {

tools/perf/ui/stdio/hist.c

181

.hit = remaining,

tools/testing/selftests/kvm/s390/cmma_test.c

393

TEST_ASSERT_EQ(args.remaining, TEST_DATA_PAGE_COUNT);

tools/testing/selftests/kvm/s390/cmma_test.c

407

TEST_ASSERT_EQ(args.remaining, 0);

tools/testing/selftests/kvm/s390/cmma_test.c

420

TEST_ASSERT_EQ(args.remaining, 0);

tools/testing/selftests/kvm/s390/cmma_test.c

439

if (args.count || args.remaining || args.start_gfn)

tools/testing/selftests/kvm/s390/cmma_test.c

443

args.remaining

tools/testing/selftests/net/busy_poller.c

210

ssize_t remaining = buflen;

tools/testing/selftests/net/busy_poller.c

216

write_result = write(fd, buf_offset, remaining);

tools/testing/selftests/net/busy_poller.c

221

remaining -= write_result;